Message.php

<?php
 
namespace Bitrix\Im\V2;
 
use ArrayAccess;
use Bitrix\Im\V2\Message\Reaction\ReactionMessage;
use Bitrix\Main\Engine\UrlManager;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\ORM\Data\DataManager;
use Bitrix\Main\Type\DateTime;
use Bitrix\Main\ObjectException;
use Bitrix\Main\UrlPreview\UrlPreview;
use Bitrix\Im;
use Bitrix\Im\User;
use Bitrix\Im\Text;
use Bitrix\Im\Notify;
use Bitrix\Im\Recent;
use Bitrix\Im\Model\EO_Message;
use Bitrix\Im\Model\MessageTable;
use Bitrix\Im\V2\Common\ContextCustomer;
use Bitrix\Im\V2\Common\FieldAccessImplementation;
use Bitrix\Im\V2\Common\ActiveRecordImplementation;
use Bitrix\Im\V2\Common\RegistryEntryImplementation;
use Bitrix\Im\V2\Entity\File\FileCollection;
use Bitrix\Im\V2\Entity\Url\UrlItem;
use Bitrix\Im\V2\Link\Pin\PinService;
use Bitrix\Im\V2\Link\Favorite\FavoriteService;
use Bitrix\Im\V2\Message\Param;
use Bitrix\Im\V2\Message\Params;
use Bitrix\Im\V2\Message\Param\Menu;
use Bitrix\Im\V2\Message\Param\Keyboard;
use Bitrix\Im\V2\Message\Param\AttachArray;
use Bitrix\Im\V2\Message\ReadService;
use Bitrix\Im\V2\Message\ViewedService;
use Bitrix\Im\V2\Message\MessageParameter;
use Bitrix\Im\V2\Rest\PopupData;
use Bitrix\Im\V2\Rest\RestEntity;
use Bitrix\Im\V2\Rest\PopupDataAggregatable;
 
class Message implements ArrayAccess, RegistryEntry, ActiveRecord, RestEntity, PopupDataAggregatable
{
    use FieldAccessImplementation;
    use ActiveRecordImplementation
    {
        save as defaultSave;
    }
    use RegistryEntryImplementation;
    use ContextCustomer;
 
    public const MESSAGE_MAX_LENGTH = 20000;
    public const REST_FIELDS = ['ID', 'CHAT_ID', 'AUTHOR_ID', 'DATE_CREATE', 'MESSAGE', 'NOTIFY_EVENT'];
 
    protected ?int $messageId = null;
 
    protected ?int $chatId = null;
 
    protected ?Chat $chat = null;
 
    protected int $authorId = 0;
    protected array $userIdsFromMention;
 
    protected ?string $message = null;
 
    protected ?string $parsedMessage = null;
 
    protected ?string $formattedMessage = null;
 
    protected ?string $messageOut = null;
 
    protected ?DateTime $dateCreate = null;
 
    protected ?string $emailTemplate = null;
 
    protected int $notifyType = \IM_NOTIFY_MESSAGE;
 
    protected ?string $notifyModule = null;
 
    protected ?string $notifyEvent = null;
 
    protected ?string $notifyTag = null;
 
    protected ?string $notifySubTag = null;
 
    protected ?string $notifyTitle = null;
 
    protected ?string $notifyLink = null;
 
    protected ?array $notifyButtons = null;
 
    protected ?bool $notifyRead = null;
 
    protected ?bool $notifyAnswer = null;
 
    protected ?bool $notifyFlash = null;
 
    protected ?int $importId = null;
 
    protected ?bool $isUnread = null;
 
    protected ?bool $isViewed = null;
 
    protected ?bool $isViewedByOthers = null;
 
    protected Params $params;
 
    protected ?FileCollection $files = null;
 
    protected ?Im\V2\Message\Reaction\ReactionMessage $reactions;
 
    protected bool $isSystem = false;
 
    protected ?UrlItem $url;
 
    protected int $botId = 0;
 
    protected ?string $uuid = null;
 
    protected ?string $forwardUuid = null;
 
    protected ?string $fileUuid = null;
 
    protected bool $isUuidFilled = false;
    protected bool $isUrlFilled = false;
 
    protected ?string $pushMessage = null;
    protected ?array $pushParams = null;
    protected ?string $pushAppId = null;
 
    protected ?bool $isImportant = false;
 
    protected ?array $importantFor = null;
 
    public function __construct($source = null)
    {
        $this->params = new Params;
 
        $this->initByDefault();
 
        if (!empty($source))
        {
            $this->load($source);
        }
    }
 
    public function save(): Result
    {
        $checkParamsIsValid = $this->getParams()->isValid();
 
        if (!$checkParamsIsValid->isSuccess())
        {
            return $checkParamsIsValid;
        }
 
        $result = $this->defaultSave();
 
        if ($result->isSuccess())
        {
            $this->params->setMessageId($this->getMessageId());
 
            $paramsSaveResult = $this->params->save();
            if (!$paramsSaveResult->isSuccess())
            {
                $result->addErrors($paramsSaveResult->getErrors());
            }
        }
 
        return $result;
    }
 
    //region Setters & Getters
 
    public function getId(): ?int
    {
        return $this->getMessageId();
    }
 
    public function markAsSystem(bool $flag): self
    {
        $this->isSystem = $flag;
 
        return $this;
    }
 
    public function isSystem(): bool
    {
        return $this->isSystem;
    }
 
    public function isDisappearing(): bool
    {
        return (bool)$this->getDisappearingTime();
    }
 
    public function getDisappearingTime(): ?DateTime
    {
        if ($this->getMessageId())
        {
            $row = Im\Model\MessageDisappearingTable::getRowById($this->getMessageId());
 
            return $row['DATE_REMOVE'];
        }
 
        return null;
    }
 
    public function isImportant(): ?bool
    {
        return $this->isImportant;
    }
 
    public function markAsImportant(?bool $isImportant = true): self
    {
        $this->isImportant = $isImportant;
 
        return $this;
    }
 
    public function getImportantFor(): array
    {
        return $this->importantFor ?? array_values($this->getUserIdsFromMention());
    }
 
    public function setImportantFor(array $importantFor): self
    {
        $this->importantFor = $importantFor;
 
        return $this;
    }
 
    public function getForwardUuid(): ?string
    {
        return $this->forwardUuid;
    }
 
    public function setForwardUuid(?string $forwardUuid): self
    {
        if ($forwardUuid && Im\Message\Uuid::validate($forwardUuid))
        {
            $this->forwardUuid = $forwardUuid;
        }
 
        return $this;
    }
 
    public function setParams($params): self
    {
        $this->getParams()->load($params);
 
        return $this;
    }
 
    public function resetParams($params): self
    {
        $this->getParams()->delete();
 
        return $this->setParams($params);
    }
 
    public function getParams(bool $disallowLazyLoad = false): Params
    {
        if (
            $disallowLazyLoad != true
            && !$this->params->isLoaded()
            && $this->getMessageId()
        )
        {
            // lazyload
            $this->params->loadByMessageId($this->getMessageId());
        }
 
        return $this->params;
    }
 
    public function setAttach($attach): self
    {
        $this->getParams()->get(Params::ATTACH)->setValue($attach);
        return $this;
    }
 
    public function getAttach(): AttachArray
    {
        return $this->getParams()->get(Params::ATTACH);
    }
 
    public function setUrl(?UrlItem $url): self
    {
        $this->url = $url;
        $this->isUrlFilled = true;
 
        return $this;
    }
 
    public function getUrl(): ?UrlItem
    {
        if (isset($this->url))
        {
            return $this->url;
        }
 
        $urlId = $this->getParams()->get(Params::URL_ID)->getValue()[0] ?? null;
        if (isset($urlId) && !$this->isUrlFilled)
        {
            return UrlItem::initByPreviewUrlId($urlId, false);
        }
 
        return null;
    }
 
    public function setUnread(bool $isUnread): self
    {
        $this->isUnread = $isUnread;
 
        return $this;
    }
 
    public function isUnread(): bool
    {
        if (isset($this->isUnread))
        {
            return $this->isUnread;
        }
 
        $messageIds = [$this->getMessageId()];
        $this->isUnread = !(new ReadService())->getReadStatusesByMessageIds($messageIds)[$this->getMessageId()];
 
        return $this->isUnread;
    }
 
    public function setViewed(bool $isViewed): self
    {
        $this->isViewed = $isViewed;
 
        return $this;
    }
 
    public function isViewed(): bool
    {
        if (isset($this->isViewed))
        {
            return $this->isViewed;
        }
 
        if ($this->authorId === $this->getContext()->getUserId())
        {
            $this->isViewed = true;
 
            return $this->isViewed;
        }
 
        $messageIds = [$this->getMessageId()];
        $this->isViewed = (new ReadService())->getViewStatusesByMessageIds($messageIds)[$this->getMessageId()];
 
        return $this->isViewed;
    }
 
    public function setViewedByOthers(bool $isViewedByOthers): self
    {
        $this->isViewedByOthers = $isViewedByOthers;
 
        return $this;
    }
 
    public function isViewedByOthers(): bool
    {
        if (isset($this->isViewedByOthers))
        {
            return $this->isViewedByOthers;
        }
 
        $this->isViewedByOthers = (new ViewedService())->getMessageStatus($this->getMessageId()) === \IM_MESSAGE_STATUS_DELIVERED;
 
        return $this->isViewedByOthers;
    }
 
    public function setBotId(int $botId): self
    {
        $this->botId = $botId;
 
        return $this;
    }
 
    public function setKeyboard($keyboard): self
    {
        if (is_array($keyboard))
        {
            $value = [];
            if (!isset($keyboard['BUTTONS']))
            {
                $value['BUTTONS'] = $keyboard;
            }
            else
            {
                $value = $keyboard;
            }
            if (!isset($value['BOT_ID']))
            {
                $value['BOT_ID'] = $this->botId;
            }
            $keyboard = $value;
        }
 
        $this->getParams()->get(Params::KEYBOARD)->setValue($keyboard);
        return $this;
    }
 
    public function getKeyboard(): Keyboard
    {
        return $this->getParams()->get(Params::KEYBOARD);
    }
 
    /*
     * @param array|Parameter|Menu $menu
     */
    public function setMenu($menu): self
    {
        if (is_array($menu))
        {
            $value = [];
            if (!isset($menu['ITEMS']))
            {
                $value['ITEMS'] = $menu;
            }
            else
            {
                $value = $menu;
            }
            if (!isset($value['BOT_ID']))
            {
                $value['BOT_ID'] = $this->botId;
            }
            $menu = $value;
        }
 
        $this->getParams()->get(Params::MENU)->setValue($menu);
        return $this;
    }
 
    public function getMenu(): Menu
    {
        return $this->getParams()->get(Params::MENU);
    }
 
    //region UUID
 
    public function setUuid(?string $uuid): self
    {
        $this->isUuidFilled = true;
 
        if ($uuid && Im\Message\Uuid::validate($uuid))
        {
            $this->uuid = $uuid;
        }
 
        return $this;
    }
 
    public function getUuid(): ?string
    {
        if ($this->isUuidFilled)
        {
            return $this->uuid;
        }
 
        $this->isUuidFilled = true;
        $this->uuid = null;
 
        if ($this->getMessageId())
        {
            $row = Im\Model\MessageUuidTable::query()
                ->setSelect(['UUID'])
                ->where('MESSAGE_ID', $this->getMessageId())
                ->fetch() ?: [];
 
            $this->uuid = $row['UUID'] ?? null;
        }
 
        return $this->uuid;
    }
 
    public function setFileUuid(?string $uuid): self
    {
        $this->fileUuid = $uuid;
        return $this;
    }
 
    public function getFileUuid(): ?string
    {
        return $this->fileUuid;
    }
 
    //endregion
 
    //region Files
 
    public function getFileIds(): array
    {
        if ($this->getParams()->isSet(Params::FILE_ID))
        {
            return $this->getParams()->get(Params::FILE_ID)->getValue();
        }
 
        return [];
    }
 
    public function hasFiles(): bool
    {
        return
            $this->getParams()->isSet(Params::FILE_ID)
            && ($this->getParams()->get(Params::FILE_ID)->count() > 0);
    }
 
    public function setFiles($files): self
    {
        $fileIds = [];
        if ($files instanceof FileCollection)
        {
            $this->files = $files;
            foreach ($this->files as $fileItem)
            {
                $fileIds[] = $fileItem->getDiskFileId();
            }
        }
        elseif (is_array($files))
        {
            $fileIds = array_filter(array_map('intval', array_values($files)));
        }
 
        $this->getParams()->get(Params::FILE_ID)->setValue($fileIds);
 
        return $this;
    }
 
    public function fillFiles(FileCollection $files): self
    {
        $this->files = $files;
 
        return $this;
    }
 
    public function addFile(Im\V2\Entity\File\FileItem $file): self
    {
        $this->getFiles()[] = $file;
        $this->getParams()->get(Params::FILE_ID)->addValue($file->getId());
 
        return $this;
    }
 
    public function getFiles(): FileCollection
    {
        if (!$this->files instanceof FileCollection)
        {
            $fileIds = $this->getFileIds();
            if (!empty($fileIds))
            {
                $this->files = FileCollection::initByDiskFilesIds($fileIds, $this->getChatId());
            }
            else
            {
                $this->files = new FileCollection;
            }
        }
 
        return $this->files;
    }
 
    public function setReactions(Im\V2\Message\Reaction\ReactionMessage $reactions): self
    {
        $this->reactions = $reactions;
 
        return $this;
    }
 
    public function getReactions(): Im\V2\Message\Reaction\ReactionMessage
    {
        $this->reactions ??= Im\V2\Message\Reaction\ReactionMessage::getByMessageId($this->getMessageId());
 
        return $this->reactions;
    }
 
    public function uploadFileFromText(): array
    {
        $files = [];
        if ($this->getMessage() && $this->getChatId())
        {
            $message = $this->getMessage();
            if (preg_match_all("/\[DISK=([0-9]+)\]/i", $message, $matches))
            {
                $fileFound = false;
                foreach ($matches[1] as $fileId)
                {
                    $newFile = \CIMDisk::SaveFromLocalDisk($this->getChatId(), $fileId, false, $this->getContext()->getUserId());
                    if ($newFile)
                    {
                        $files[] = $newFile;
                        $fileFound = true;
                        $file = new Im\V2\Entity\File\FileItem($newFile, $this->getChatId());
                        $this->addFile($file);
                    }
                }
                if ($fileFound)
                {
                    $message = preg_replace("/\[DISK\=([0-9]+)\]/i", '', $message);
                }
                $this->setMessage($message);
            }
        }
 
        return $files;
    }
 
    public function formatFilesMessageOut(): self
    {
        if ($this->getChatId() && $this->hasFiles())
        {
            $messageFiles = $this->formatFileLinks();
            if (!empty($messageFiles))
            {
                $messageOut = $this->getMessageOut() ? $this->getMessageOut() . "\n" : '';
                $messageOut .= implode("\n", $messageFiles);
                $this->setMessageOut($messageOut);
            }
        }
 
        return $this;
    }
 
    public function getFilesDiskData(): array
    {
        if ($this->hasFiles())
        {
            return $this->getFiles()->getFileDiskAttributes($this->getChatId());
        }
 
        return  [];
    }
 
    private function formatFileLinks(): array
    {
        $messageFiles = [];
 
        $filesDataList = $this->getFilesDiskData();
        if (!empty($filesDataList))
        {
            $urlManager = UrlManager::getInstance();
            $hostUrl = $urlManager->getHostUrl();
            foreach ($filesDataList as $fileData)
            {
                if ($fileData['status'] == 'done')
                {
                    $messageFiles[] =
                        $fileData['name'] . ' (' . \CFile::formatSize($fileData['size']) . ')'
                        . "\n" . Loc::getMessage('IM_MESSAGE_FILE_DOWN')
                        . ' ' . $hostUrl . $fileData['urlDownload']
                        . "\n";
                }
            }
        }
 
        return $messageFiles;
    }
 
    //endregion
 
    public function getReminder(): ?Link\Reminder\ReminderItem
    {
        return Link\Reminder\ReminderItem::getByMessageAndUserId($this, $this->getContext()->getUserId());
    }
 
    public function getAdditionalMessageIds(): array
    {
        $ids = [];
 
        if ($this->getParams()->isSet(Params::REPLY_ID))
        {
            $ids[] = $this->getParams()->get(Params::REPLY_ID)->getValue();
        }
 
        return $ids;
    }
 
    public function getPopupData(array $excludedList = []): PopupData
    {
        $data = new PopupData([
            new Im\V2\Entity\User\UserPopupItem($this->getUserIds()),
            new Im\V2\Entity\File\FilePopupItem(),
            new Im\V2\Link\Reminder\ReminderPopupItem(),
            new Im\V2\Message\Reaction\ReactionPopupItem($this->getReactions()),
        ], $excludedList);
 
        if (!in_array(Im\V2\Entity\File\FilePopupItem::class, $excludedList, true))
        {
            $data->add(new Im\V2\Entity\File\FilePopupItem($this->getFiles()));
        }
 
        if (!in_array(Im\V2\Link\Reminder\ReminderPopupItem::class, $excludedList, true))
        {
            $data->add(new Im\V2\Link\Reminder\ReminderPopupItem($this->getReminder()));
        }
 
        return $data->mergeFromEntity($this->getReactions());
    }
 
    public function setMessageId(int $messageId): self
    {
        if (!$this->messageId)
        {
            $this->messageId = $messageId;
            $this->params->setMessageId($messageId);
        }
        return $this;
    }
 
    public function getMessageId(): ?int
    {
        return $this->messageId;
    }
 
    public function setAuthorId(int $authorId): self
    {
        $this->authorId = $authorId;
 
        $this->processChangeAuthorId($authorId);
 
        return $this;
    }
 
    public function processChangeAuthorId(int $authorId): int
    {
        if ($authorId === 0)
        {
            $this->markAsSystem(true);
        }
 
        return $authorId;
    }
 
    public function getAuthorId(): int
    {
        return $this->authorId;
    }
 
    public function getAuthor(): ?User
    {
        if ($this->getAuthorId())
        {
            return User::getInstance($this->getAuthorId());
        }
 
        return null;
    }
 
    public function setChatId(int $value): self
    {
        $this->chatId = $value;
        return $this;
    }
 
    public function setChat(Chat $chat): self
    {
        $this->chat = $chat;
        return $this;
    }
 
    public function getChatId(): ?int
    {
        return $this->chatId;
    }
 
    public function getChat(): Chat
    {
        if (!$this->chat)
        {
            if ($this->getChatId())
            {
                $this->chat = Chat::getInstance($this->getChatId());
            }
            if ($this->chat)
            {
                $this->setRegistry($this->chat->getMessageRegistry());
            }
            else
            {
                return new Im\V2\Chat\NullChat();
            }
        }
 
        return $this->chat;
    }
 
    // message
    public function setMessage(?string $value): self
    {
        if ($value)
        {
            $value = \trim(\str_replace(['[BR]', '[br]', '#BR#'], "\n", $value));
 
            if (\mb_strlen($value) > self::MESSAGE_MAX_LENGTH + 6)
            {
                $value = \mb_substr($value, 0, self::MESSAGE_MAX_LENGTH). ' (...)';
            }
        }
 
        $this->message = $value ?: '';
        unset($this->parsedMessage, $this->formattedMessage, $this->url);
        return $this;
    }
 
    public function getMessage(): ?string
    {
        return $this->message;
    }
 
    public function getParsedMessage(): string
    {
        $this->parsedMessage ??= Im\Text::parse($this->getMessage() ?? '');
 
        return $this->parsedMessage;
    }
 
    public function getFormattedMessage(): string
    {
        if (isset($this->formattedMessage))
        {
            return $this->formattedMessage;
        }
 
        $this->formattedMessage =
            $this->isCompletelyEmpty()
                ? Loc::getMessage('IM_MESSAGE_DELETED')
                : $this->getParsedMessage()
        ;
 
        return $this->formattedMessage;
    }
 
    public function getQuotedMessage(?int $messageSize = null): string
    {
        $user = $this->getAuthor();
        $userName = isset($user) ? $user->getFullName(false) : '';
        $date = FormatDate('X', $this->getDateCreate(), time() + \CTimeZone::GetOffset());
        $contextTag = $this->getContextTag();
        $quoteDelimiter = '------------------------------------------------------';
        $messageContent = $this->getPreviewMessage($messageSize);
 
        $quotedMessage =
            $quoteDelimiter
            . "\n"
            . "{$userName} [{$date}] $contextTag\n"
            . $messageContent
            . "\n"
            . $quoteDelimiter
        ;
 
        return $quotedMessage;
    }
 
    public function getReplaceMap(): array
    {
        return Im\Text::getReplaceMap($this->getFormattedMessage());
    }
 
    // formatted rich message to output
    public function setMessageOut(?string $value): self
    {
        $this->messageOut = $value ? trim($value) : '';
        return $this;
    }
 
    public function getMessageOut(): ?string
    {
        return $this->messageOut;
    }
 
    // date create
 
    public function setDateCreate($value): self
    {
        if (!empty($value) && !($value instanceof DateTime))
        {
            try
            {
                $value = new DateTime($value);
            }
            catch (ObjectException $exception)
            {}
        }
        $this->dateCreate = $value ?: null;
        return $this;
    }
 
    public function getDateCreate(): ?DateTime
    {
        return $this->dateCreate;
    }
 
    public function getDefaultDateCreate(): DateTime
    {
        return new DateTime;
    }
 
    public function setEmailTemplate(?string $value): self
    {
        $this->emailTemplate = $value ?: '';
        return $this;
    }
 
    public function getEmailTemplate(): ?string
    {
        return $this->emailTemplate;
    }
 
    public function setNotifyType(?int $value): self
    {
        if (in_array($value, [\IM_NOTIFY_MESSAGE, \IM_NOTIFY_CONFIRM, \IM_NOTIFY_SYSTEM, \IM_NOTIFY_FROM], true))
        {
            $this->notifyType = $value;
        }
        return $this;
    }
 
    public function getNotifyType(): int
    {
        return $this->notifyType;
    }
 
    public function getDefaultNotifyType(): int
    {
        return \IM_NOTIFY_MESSAGE;
    }
 
    public function setNotifyModule(?string $value): self
    {
        $this->notifyModule = $value;
        return $this;
    }
 
    public function getNotifyModule(): ?string
    {
        return $this->notifyModule;
    }
 
    public function getDefaultNotifyModule(): ?string
    {
        return 'im';
    }
 
    public function setNotifyEvent(?string $notifyEvent): self
    {
        $this->notifyEvent = $notifyEvent;
 
        $this->processChangeNotifyEvent($notifyEvent);
 
        return $this;
    }
 
    public function processChangeNotifyEvent(?string $notifyEvent): ?string
    {
        if ($notifyEvent === Notify::EVENT_PRIVATE_SYSTEM)
        {
            $this->markAsSystem(true);
        }
 
        return $notifyEvent;
    }
 
    public function getNotifyEvent(): ?string
    {
        return $this->notifyEvent;
    }
 
    public function getDefaultNotifyEvent(): ?string
    {
        return Notify::EVENT_DEFAULT;
    }
 
    public function setNotifyTag(?string $value): self
    {
        $this->notifyTag = $value;
        return $this;
    }
 
    public function getNotifyTag(): ?string
    {
        return $this->notifyTag;
    }
 
    public function setNotifySubTag(?string $value): self
    {
        $this->notifySubTag = $value;
        return $this;
    }
 
    public function getNotifySubTag(): ?string
    {
        return $this->notifySubTag;
    }
 
    public function setNotifyTitle(?string $value): self
    {
        $this->notifyTitle = $value ? mb_substr(trim($value), 0, 255) : null;
        return $this;
    }
 
    public function getNotifyTitle(): ?string
    {
        return $this->notifyTitle;
    }
 
    public function setNotifyLink(?string $value): self
    {
        $this->notifyLink = $value;
        return $this;
    }
 
    public function getNotifyLink(): ?string
    {
        return $this->notifyLink;
    }
 
    public function setNotifyButtons($value): self
    {
        if (is_string($value))
        {
            $value = $this->unserializeNotifyButtons($value);
        }
        $this->notifyButtons = $value;
        return $this;
    }
 
    public function getNotifyButtons(): ?array
    {
        return $this->notifyButtons;
    }
 
    protected function serializeNotifyButtons($value)
    {
        return $value ? serialize($value) : null;
    }
 
    protected function unserializeNotifyButtons($value)
    {
        return $value ? unserialize($value, ['allowed_classes' => false]) : null;
    }
 
    public function markNotifyRead(?bool $value): self
    {
        $this->notifyRead = $value ?: false;
        return $this;
    }
 
    public function isNotifyRead(): ?bool
    {
        return $this->notifyRead;
    }
 
    public function getDefaultNotifyRead(): bool
    {
        return false;
    }
 
    public function markNotifyAnswer(?bool $value): self
    {
        $this->notifyAnswer = $value ?: false;
        return $this;
    }
 
    public function allowNotifyAnswer(): ?bool
    {
        return $this->notifyAnswer;
    }
 
    public function markNotifyFlash(?bool $value): self
    {
        $this->notifyFlash = $value;
        return $this;
    }
 
    public function isNotifyFlash(): ?bool
    {
        return $this->notifyFlash;
    }
 
    public function setImportId(?int $value): self
    {
        $this->importId = $value;
        return $this;
    }
 
    public function getImportId(): ?int
    {
        return $this->importId;
    }
 
    //endregion
 
    //region Push
 
    public function setPushMessage(?string $message): self
    {
        $this->pushMessage = $message;
        return $this;
    }
 
    public function getPushMessage(): ?string
    {
        return $this->pushMessage;
    }
 
    public function setPushParams(?array $params): self
    {
        $this->pushParams = $params;
        return $this;
    }
 
    public function getPushParams(): ?array
    {
        return $this->pushParams;
    }
 
    public function setPushAppId(?string $message): self
    {
        $this->pushAppId = $message;
        return $this;
    }
 
    public function getPushAppId(): ?string
    {
        return $this->pushAppId;
    }
 
 
    //endregion
 
    //region Data storage
 
    protected static function mirrorDataEntityFields(): array
    {
        return [
            'ID' => [
                'primary' => true,
                'field' => 'messageId', 
                'set' => 'setMessageId', 
                'get' => 'getMessageId', 
            ],
            'CHAT_ID' => [
                'field' => 'chatId', 
                'set' => 'setChatId', 
                'get' => 'getChatId', 
            ],
            'AUTHOR_ID' => [
                'field' => 'authorId', 
                'set' => 'setAuthorId', 
                'get' => 'getAuthorId', 
                'loadFilter' => 'processChangeAuthorId', 
            ],
            'FROM_USER_ID' => [
                'alias' => 'AUTHOR_ID',
            ],
            'MESSAGE' => [
                'field' => 'message', 
                'set' => 'setMessage', 
                'get' => 'getMessage', 
            ],
            'MESSAGE_OUT' => [
                'field' => 'messageOut', 
                'set' => 'setMessageOut', 
                'get' => 'getMessageOut', 
            ],
            'DATE_CREATE' => [
                'field' => 'dateCreate', 
                'set' => 'setDateCreate', 
                'get' => 'getDateCreate', 
                'default' => 'getDefaultDateCreate', 
            ],
            'MESSAGE_DATE' =>
                [
                    'alias' => 'DATE_CREATE',
                ],
            'EMAIL_TEMPLATE' => [
                'field' => 'emailTemplate', 
                'set' => 'setEmailTemplate', 
                'get' => 'getEmailTemplate', 
            ],
            'NOTIFY_TYPE' => [
                'field' => 'notifyType', 
                'set' => 'setNotifyType', 
                'get' => 'getNotifyType', 
                'default' => 'getDefaultNotifyType',
            ],
            'NOTIFY_MODULE' => [
                'field' => 'notifyModule', 
                'set' => 'setNotifyModule', 
                'get' => 'getNotifyModule', 
                'default' => 'getDefaultNotifyModule',
            ],
            'NOTIFY_EVENT' => [
                'field' => 'notifyEvent', 
                'set' => 'setNotifyEvent', 
                'get' => 'getNotifyEvent', 
                'default' => 'getDefaultNotifyEvent', 
                'loadFilter' => 'processChangeNotifyEvent', 
            ],
            'NOTIFY_TAG' => [
                'field' => 'notifyTag', 
                'set' => 'setNotifyTag', 
                'get' => 'getNotifyTag', 
            ],
            'NOTIFY_SUB_TAG' => [
                'field' => 'notifySubTag', 
                'set' => 'setNotifySubTag', 
                'get' => 'getNotifySubTag', 
            ],
            'NOTIFY_TITLE' => [
                'field' => 'notifyTitle', 
                'set' => 'setNotifyTitle', 
                'get' => 'getNotifyTitle', 
            ],
            'NOTIFY_LINK' => [
                'set' => 'setNotifyLink', 
                'get' => 'getNotifyLink', 
            ],
            'TITLE' => [
                'alias' => 'NOTIFY_TITLE',
            ],
            'NOTIFY_MESSAGE' => [
                'alias' => 'MESSAGE',
            ],
            'NOTIFY_MESSAGE_OUT' => [
                'alias' => 'MESSAGE_OUT',
            ],
            'NOTIFY_BUTTONS' => [
                'field' => 'notifyButtons', 
                'set' => 'setNotifyButtons', 
                'get' => 'getNotifyButtons', 
                'saveFilter' => 'serializeNotifyButtons', 
                'loadFilter' => 'unserializeNotifyButtons', 
            ],
            'NOTIFY_READ' => [
                'field' => 'notifyRead', 
                'set' => 'markNotifyRead', 
                'get' => 'isNotifyRead', 
                'default' => 'getDefaultNotifyRead',
            ],
            'NOTIFY_ANSWER' => [
                'set' => 'markNotifyAnswer', 
                'get' => 'allowNotifyAnswer', 
            ],
            'NOTIFY_FLASH' => [
                'set' => 'markNotifyFlash', 
                'get' => 'isNotifyFlash', 
            ],
            'NOTIFY_ONLY_FLASH' => [
                'alias' => 'NOTIFY_FLASH',
            ],
            'IMPORT_ID' => [
                'field' => 'importId', 
                'set' => 'setImportId', 
                'get' => 'getImportId', 
            ],
            'SYSTEM' => [
                'set' => 'markAsSystem', 
                'get' => 'isSystem', 
            ],
            'PARAMS' => [
                'set' => 'setParams', 
                'get' => 'getParams', 
            ],
            'ATTACH' => [
                'set' => 'setAttach', 
                'get' => 'getAttach', 
            ],
            'FILES' => [
                'set' => 'setFiles', 
                'get' => 'getFiles', 
            ],
            'KEYBOARD' => [
                'set' => 'setKeyboard', 
                'get' => 'getKeyboard', 
            ],
            'MENU' => [
                'set' => 'setMenu', 
                'get' => 'getMenu', 
            ],
            'UUID' => [
                'set' => 'setUuid', 
                'get' => 'getUuid', 
            ],
            'MESSAGE_UUID' => [
                'alias' => 'UUID',
            ],
            'TEMPLATE_ID' => [
                'alias' => 'UUID',
            ],
            'FILE_TEMPLATE_ID' => [
                'set' => 'setFileUuid', 
                'get' => 'getFileUuid', 
            ],
            'PUSH_MESSAGE' => [
                'set' => 'setPushMessage', 
                'get' => 'getPushMessage', 
            ],
            'MESSAGE_PUSH' => [
                'alias' => 'PUSH_MESSAGE'
            ],
            'PUSH_PARAMS' => [
                'set' => 'setPushParams', 
                'get' => 'getPushParams', 
            ],
            'EXTRA_PARAMS' => [
                'alias' => 'PUSH_PARAMS'
            ],
            'PUSH_APP_ID' => [
                'set' => 'setPushAppId', 
                'get' => 'getPushAppId', 
            ],
        ];
    }
 
    public static function getDataClass(): string
    {
        return MessageTable::class;
    }
 
    public function getPrimaryId(): ?int
    {
        return $this->getMessageId();
    }
 
    public function setPrimaryId(int $primaryId): self
    {
        return $this->setMessageId($primaryId);
    }
 
    //endregion
 
    public function markAsFavorite(): Result
    {
        $favoriteMessageService = new FavoriteService();
        $favoriteMessageService->setContext($this->context);
 
        return $favoriteMessageService->markMessageAsFavorite($this);
    }
 
    public function unmarkAsFavorite(): Result
    {
        $favoriteMessageService = new FavoriteService();
        $favoriteMessageService->setContext($this->context);
 
        return $favoriteMessageService->unmarkMessageAsFavorite($this);
    }
 
    public function pin(): Result
    {
        $pinService = new PinService();
        $pinService->setContext($this->context);
 
        return $pinService->pinMessage($this);
    }
 
    public function unpin(): Result
    {
        $pinService = new PinService();
        $pinService->setContext($this->context);
 
        return $pinService->unpinMessage($this);
    }
 
    public function mark(): Result
    {
        $result = new Result();
 
        $isSuccessMark = Recent::unread(
            $this->getChat()->getDialogId(),
            true,
            $this->getContext()->getUserId(),
            $this->getId()
        );
 
        if (!$isSuccessMark)
        {
            $result->addError(new Im\V2\Message\MessageError(Im\V2\Message\MessageError::MARK_FAILED));
        }
 
        return $result;
    }
 
    public function addToReminder(DateTime $dateRemind): Result
    {
        $reminderService = new Link\Reminder\ReminderService();
        $reminderService->setContext($this->context);
 
        return $reminderService->addMessageToReminders($this, $dateRemind);
    }
 
    public function getPreviewMessage(?int $messageSize = 200): string
    {
        $previewMessage = trim($this->getFormattedMessage());
        $hasFiles = $this->hasFiles();
        $hasAttach = mb_strpos($previewMessage, '[ATTACH=') !== false;
 
        if ($this->getRegistry() instanceof MessageCollection)
        {
            $this->getRegistry()->fillFiles();
        }
 
        if ($hasFiles)
        {
            $files = $this->getFiles();
            foreach ($files as $file)
            {
                $hasFiles = true;
                $previewMessage .= " [{$file->getDiskFile()->getName()}]";
            }
        }
 
        $previewMessage = preg_replace(
            "/\[ATTACH=([0-9]{1,})\]/i",
            " [".Loc::getMessage('IM_MESSAGE_ATTACH')."] ",
            $previewMessage
        );
        $previewMessage = preg_replace(
            '#\-{54}.+?\-{54}#s',
            " [".Loc::getMessage('IM_MESSAGE_QUOTE')."] ",
            str_replace(["#BR#"], [" "], $previewMessage)
        );
        $previewMessage = preg_replace(
            '/^(>>(.*)(\n)?)/mi',
            " [".Loc::getMessage('IM_MESSAGE_QUOTE')."] ",
            str_replace(["#BR#"], [" "], $previewMessage)
        );
 
        if (!$hasFiles && !$hasAttach)
        {
            if ($this->getParams()->isSet(Params::ATTACH))
            {
                $previewMessage .= " [".Loc::getMessage('IM_MESSAGE_ATTACH')."]";
            }
        }
 
        if ($messageSize !== null)
        {
            $dots = mb_strlen($previewMessage) >= $messageSize ? '...' : '';
            $previewMessage = mb_substr($previewMessage, 0, $messageSize - 1) . $dots;
        }
 
        return $previewMessage;
    }
 
    public function getForPush(?int $messageSize = 200): string
    {
        if ($this->getRegistry() instanceof MessageCollection)
        {
            $this->getRegistry()->fillFiles();
        }
 
        $files = [];
 
        foreach ($this->getFiles() as $file)
        {
            $files[] = ['name' => $file->getDiskFile()->getName()];
        }
 
        $message = ['MESSAGE' => $this->getMessage(), 'FILES' => $files];
        $text = \CIMMessenger::PrepareParamsForPush($message);
 
        if ($messageSize !== null)
        {
            $dots = mb_strlen($text) >= $messageSize ? '...' : '';
            $text = mb_substr($text, 0, $messageSize - 1) . $dots;
        }
 
        return $text;
    }
 
    public function hasAccess(?int $userId = null): bool
    {
        $userId ??= $this->getContext()->getUserId();
        $chat = $this->getChat();
 
        return $this->getId() && $chat->hasAccess($userId) && $chat->getStartId($userId) <= $this->getId();
    }
 
    public static function getRestEntityName(): string
    {
        return 'message';
    }
 
    public function getUserIds(): array
    {
        $userIds = $this->getUserIdsFromMention();
 
        if ($this->getAuthorId() !== 0)
        {
            $userIds[$this->getAuthorId()] = $this->getAuthorId();
        }
 
        if ($this->getParams()->isSet(Params::FORWARD_USER_ID))
        {
            $userId = (int)$this->getParams()->get(Params::FORWARD_USER_ID)->getValue();
            $userIds[$userId] = $userId;
        }
 
        return $userIds;
    }
 
    protected function getUserIdsFromMention(): array
    {
        if (isset($this->userIdsFromMention))
        {
            return $this->userIdsFromMention;
        }
 
        $this->userIdsFromMention = [];
        if (preg_match_all("/\[USER=([0-9]+)( REPLACE)?](.*?)\[\/USER]/i", $this->getParsedMessage(), $matches))
        {
            foreach ($matches[1] as $userId)
            {
                $this->userIdsFromMention[(int)$userId] = (int)$userId;
            }
        }
 
        return $this->userIdsFromMention;
    }
 
    public function getEnrichedParams(): Params
    {
        $params = clone $this->getParams();
 
        $url = $this->getUrl();
        if (isset($url))
        {
            $params->get(Params::ATTACH)->addValue($url->getUrlAttach());
        }
 
        if ($this->isCompletelyEmpty())
        {
            $params->get(Params::IS_DELETED)->setValue(true);
        }
 
        return $params;
    }
 
    public function isCompletelyEmpty(): bool
    {
        return (
            $this->getParsedMessage() === ''
            && !$this->getParams()->isSet(Params::FILE_ID)
            && !$this->getParams()->isSet(Params::KEYBOARD)
            && !$this->getParams()->isSet(Params::ATTACH)
        );
    }
 
    public function getContextId(): string
    {
        $chat = $this->getChat();
 
        if ($chat instanceof Im\V2\Chat\PrivateChat)
        {
            $userIds = $chat->getRelations()->getUserIds();
            $implodeUserIds = implode(':', $userIds);
 
            return "{$implodeUserIds}/{$this->getMessageId()}";
        }
 
        return "{$chat->getDialogId()}/{$this->getMessageId()}";
    }
 
    protected function getContextTag(): string
    {
        return "#{$this->getContextId()}";
    }
 
    public function isForward(): bool
    {
        return $this->getParams()->isSet(Params::FORWARD_ID)
            && $this->getParams()->isSet(Params::FORWARD_CONTEXT_ID)
        ;
    }
 
    protected function getForwardInfo(): ?array
    {
        if (!$this->isForward())
        {
            return null;
        }
 
        return [
            'id' => $this->getParams()->get(Params::FORWARD_CONTEXT_ID)->getValue(),
            'userId' => (int)$this->getParams()->get(Params::FORWARD_USER_ID)->getValue(),
        ];
    }
 
    public function toRestFormat(array $option = []): array
    {
        $dateCreate = $this->getDateCreate();
        $authorId = $this->getNotifyEvent() === Notify::EVENT_SYSTEM ? 0 : $this->getAuthorId();
        $onlyCommonRest = [
            'id' => $this->getId(),
            'chat_id' => $this->getChatId(),
            'author_id' => $authorId,
            'date' => isset($dateCreate) ? $dateCreate->format('c') : null,
            'text' => $this->getFormattedMessage(),
            'isSystem' => $this->isSystem(),
            'replaces' => $this->getReplaceMap(),
            'uuid' => $this->getUuid(),
            'forward' => $this->getForwardInfo(),
            'params' => $this->getEnrichedParams()->toRestFormat(),
        ];
        $rest = $onlyCommonRest;
 
        if (!isset($option['MESSAGE_ONLY_COMMON_FIELDS']) || $option['MESSAGE_ONLY_COMMON_FIELDS'] === false)
        {
            $rest = array_merge($onlyCommonRest, [
                'unread' => $this->isUnread(),
                'viewed' => $this->isViewed(),
                'viewedByOthers' => $this->isViewedByOthers(),
            ]);
        }
 
        return $rest;
    }
 
    public function generateUrlPreview(): void
    {
        if ($this->getMessage())
        {
            $urls = UrlItem::getUrlsFromText($this->getMessage());
            foreach ($urls as $url)
            {
                $metadata = UrlPreview::getMetadataByUrl($url, true, false);
                if ($metadata !== false)
                {
                    $urlItem = UrlItem::initByMetadata($metadata);
                    if ($urlItem->getId())
                    {
                        $this->getParams()->get(Params::URL_ID)->addValue($urlItem->getId());
                        $this->getParams()->get(Params::ATTACH)->addValue($urlItem->getUrlAttach());
 
                        // check if message contains only link
                        if ($urlItem->isStaticUrl())
                        {
                            $staticUrl = [$url];
                            if (mb_substr($url, -1) == '/')
                            {
                                $staticUrl[] = mb_substr($url, 0, -1);
                            }
                            $checkMessage = trim(str_replace($staticUrl, '', $this->getMessage()));
 
                            if (empty($checkMessage))
                            {
                                $this->getParams()->get(Params::URL_ONLY)->setValue(true);
                            }
                        }
                    }
                }
            }
        }
    }
 
    public function parseDates(): self
    {
        if ($this->getMessage())
        {
            $dateConvertResult = Text::getDateConverterParams($this->getMessage());
            foreach ($dateConvertResult as $row)
            {
                $this->getParams()->get(Params::DATE_TEXT)->addValue($row->getText());
                $this->getParams()->get(Params::DATE_TS)->addValue($row->getDate()->getTimestamp());
            }
        }
 
        return $this;
    }
 
    public function checkEmoji(): self
    {
        if ($this->getMessage())
        {
            if (Text::isOnlyEmoji($this->getMessage()))
            {
                $this->getParams()->get(Params::LARGE_FONT)->setValue(true);
            }
        }
 
        return $this;
    }
 
    public function autocompleteParams(bool $urlPreview): self
    {
        $this->getParams()->get(Params::LARGE_FONT)->setValue(Text::isOnlyEmoji($this->getMessage() ?? ''));
        $dateText = [];
        $dateTs = [];
        $urlIds = [];
        $isUrlOnly = false;
        if ($urlPreview)
        {
            $results = Text::getDateConverterParams($this->getMessage() ?? '');
            foreach ($results as $result)
            {
                $dateText[] = $result->getText();
                $dateTs[] = $result->getDate()->getTimestamp();
            }
 
            $url = UrlItem::getByMessage($this);
            if (isset($url))
            {
                if ($url->getId() !== null)
                {
                    $urlIds[] = $url->getId();
                }
                $this->setUrl($url);
                $isUrlOnly = $this->isUrlOnly($url);
            }
        }
        $this->getParams()->get(Params::DATE_TEXT)->setValue($dateText);
        $this->getParams()->get(Params::DATE_TS)->setValue($dateTs);
        $this->getParams()->get(Params::URL_ID)->setValue($urlIds);
        $this->getParams()->get(Params::URL_ONLY)->setValue($isUrlOnly);
 
        return $this;
    }
 
    private function isUrlOnly(?UrlItem $url): bool
    {
        if ($url === null)
        {
            return false;
        }
 
        if (!$url->isStaticUrl())
        {
            return false;
        }
 
        $messageWithoutUrl = str_replace($url->getUrl(), '', $this->getMessage() ?? '');
 
        return trim($messageWithoutUrl) === '';
    }
 
    public function updateSearchIndex(): void
    {
        if ($this->getMessageId())
        {
            MessageTable::indexRecord($this->getMessageId());
        }
    }
 
    public static function loadPhrases(): void
    {
        Loc::loadMessages(__FILE__);
    }
 
    public function deleteSoft(): Result
    {
        $service = new Im\V2\Message\Delete\DeleteService($this);
        $service->setMode(Im\V2\Message\Delete\DeleteService::MODE_SOFT);
        return $service->delete();
    }
 
    public function deleteHard(): Result
    {
        $service = new Im\V2\Message\Delete\DeleteService($this);
        $service->setMode(Im\V2\Message\Delete\DeleteService::MODE_HARD);
        return $service->delete();
    }
 
    public function deleteComplete(): Result
    {
        $service = new Im\V2\Message\Delete\DeleteService($this);
        $service->setMode(Im\V2\Message\Delete\DeleteService::MODE_COMPLETE);
        return $service->delete();
    }
}