ReadService.php

<?php
 
namespace Bitrix\Im\V2\Message;
 
use Bitrix\Im\Model\ChatTable;
use Bitrix\Im\Model\MessageUnreadTable;
use Bitrix\Im\Model\MessageViewedTable;
use Bitrix\Im\Model\RelationTable;
use Bitrix\Im\Recent;
use Bitrix\Im\V2\Chat;
use Bitrix\Im\V2\Common\ContextCustomer;
use Bitrix\Im\V2\Entity\User\UserCollection;
use Bitrix\Im\V2\Message;
use Bitrix\Im\V2\MessageCollection;
use Bitrix\Im\V2\Relation;
use Bitrix\Im\V2\RelationCollection;
use Bitrix\Im\V2\Result;
use Bitrix\Im\V2\Service\Context;
use Bitrix\Im\V2\Sync;
use Bitrix\Main\Application;
use Bitrix\Main\Loader;
 
class ReadService
{
    use ContextCustomer
    {
        setContext as private defaultSetContext;
    }
 
    protected CounterService $counterService;
    protected ViewedService $viewedService;
 
    private static array $lastMessageIdCache = [];
 
    public function __construct(?int $userId = null)
    {
        $this->counterService = new CounterService();
        $this->viewedService = new ViewedService();
 
        if (isset($userId))
        {
            $context = new Context();
            $context->setUser($userId);
            $this->setContext($context);
            $this->counterService->setContext($context);
            $this->viewedService->setContext($context);
        }
    }
 
    public function readTo(Message $message): Result
    {
        $this->setLastIdForRead($message->getMessageId(), $message->getChatId());
        $this->counterService->deleteTo($message);
        $counter = $this->counterService->getByChat($message->getChatId());
        $viewResult = $this->viewedService->addTo($message);
        $this->updateDateRecent($message->getChatId());
        if (!$message->getChat() instanceof Chat\OpenLineChat)
        {
            Sync\Logger::getInstance()->add(
                new Sync\Event(Sync\Event::ADD_EVENT, Sync\Event::CHAT_ENTITY, $message->getChatId()),
                $this->getContext()->getUserId()
            );
        }
 
        $viewedMessages = [];
        if ($viewResult->isSuccess())
        {
            $viewedMessages = $viewResult->getResult()['VIEWED_MESSAGES'] ?? [];
        }
 
        return (new Result())->setResult(['COUNTER' => $counter, 'VIEWED_MESSAGES' => $viewedMessages]);
    }
 
    public function read(MessageCollection $messages, Chat $chat): Result
    {
        $maxId = max($messages->getIds());
        $this->setLastIdForRead($maxId, $chat->getChatId());
        $this->counterService->deleteTo($messages[$maxId]);
        $counter = $this->counterService->getByChat($chat->getChatId());
        $messagesToView = $messages
            ->withContextUser($this->getContext()->getUserId())
            ->fillViewed()
            ->filter(fn (Message $message) => !$message->isViewed())
        ;
        $this->viewedService->add($messagesToView);
        $this->updateDateRecent($chat->getChatId());
        if (!$chat instanceof Chat\OpenLineChat)
        {
            Sync\Logger::getInstance()->add(
                new Sync\Event(Sync\Event::ADD_EVENT, Sync\Event::CHAT_ENTITY, $chat->getChatId()),
                $this->getContext()->getUserId()
            );
        }
 
        return (new Result())->setResult(['COUNTER' => $counter, 'VIEWED_MESSAGES' => $messagesToView]);
    }
 
    public function readNotifications(MessageCollection $messages, array $userByChatId): Result
    {
        $chatIds = [];
 
        foreach ($messages as $message)
        {
            $chatIds[$message->getChatId()] = 0;
        }
 
        $chatIds = array_keys($chatIds);
 
        $this->counterService->deleteByMessageIdsForAll($messages->getIds(), $userByChatId);
        $counters = $this->counterService->getForNotifyChats($chatIds);
        $time = microtime(true);
        //$this->viewedController->add($messages);
 
        /*foreach ($chatIds as $chatId)
        {
            $this->sendPush($chatId, [(int)$userByChatId[$chatId]], $counters[$chatId], $time);
            Sync\Logger::getInstance()->add(
                new Sync\Event(Sync\Event::ADD_EVENT, Sync\Event::CHAT_ENTITY, $chatId),
                (int)$userByChatId[$chatId]
            );
        }*/
 
        return (new Result())->setResult(['COUNTERS' => $counters]);
    }
 
    public function readAllInChat(int $chatId): Result
    {
        $lastId = $this->getLastMessageIdInChat($chatId);
        $this->setLastIdForRead($lastId, $chatId);
        $this->counterService->deleteByChatId($chatId);
        $counter = 0;
        //$this->viewedController->addAllFromChat($chatId);
        $this->updateDateRecent($chatId);
        if (!Chat::getInstance($chatId) instanceof Chat\OpenLineChat)
        {
            Sync\Logger::getInstance()->add(
                new Sync\Event(Sync\Event::ADD_EVENT, Sync\Event::CHAT_ENTITY, $chatId),
                $this->getContext()->getUserId()
            );
        }
 
        return (new Result())->setResult(['COUNTER' => $counter, 'VIEWED_MESSAGES' => new MessageCollection()]);
    }
 
    public function readAll(): void
    {
        $this->setLastIdForReadAll();
        $this->counterService->deleteAll();
        Sync\Logger::getInstance()->add(
            new Sync\Event(Sync\Event::READ_ALL_EVENT, Sync\Event::CHAT_ENTITY, 0),
            $this->getContext()->getUserId()
        );
    }
 
    public function unreadTo(Message $message): Result
    {
        //$this->setLastIdForUnread($message->getMessageId(), $message->getChatId());
        $relation = $message->getChat()->withContext($this->context)->getSelfRelation();
        if ($relation === null)
        {
            return new Result();
        }
        $this->counterService->addStartingFrom($message->getMessageId(), $relation);
        $this->viewedService->deleteStartingFrom($message);
        if (!$message->getChat() instanceof Chat\OpenLineChat)
        {
            Sync\Logger::getInstance()->add(
                new Sync\Event(Sync\Event::ADD_EVENT, Sync\Event::CHAT_ENTITY, $message->getChatId()),
                $this->getContext()->getUserId()
            );
        }
 
        return new Result();
    }
 
    public function unreadNotifications(MessageCollection $messages, Relation $relation): Result
    {
        $this->counterService->addCollection($messages, $relation);
        $counter = $this->counterService->getByChat($relation->getChatId());
 
        return (new Result())->setResult(['COUNTER' => $counter]);
    }
 
    public function markNotificationUnread(Message $message, RelationCollection $relations): self
    {
        $this->counterService->addForEachUser($message, $relations);
        return $this;
    }
 
    public function markMessageUnread(Message $message, RelationCollection $relations): self
    {
        $this->counterService->addForEachUser($message, $relations);
        $this->counterService->deleteTo($message);
        return $this;
    }
 
    public function markRecentUnread(Message $message): self
    {
        Recent::unread($message->getChat()->withContext($this->context)->getDialogId(), false, $this->getContext()->getUserId());
        return $this;
    }
 
    public function getCountersForUsers(Message $message, RelationCollection $relations): array
    {
        return $this->counterService->getByChatForEachUsers($message->getChatId(), $relations->getUserIds());
    }
 
    public function onAfterMessageSend(Message $message, RelationCollection $relations, bool $withoutCounters = false): Result
    {
        if (!$withoutCounters)
        {
            $this->markMessageUnread($message, $relations);
        }
 
        $counters = $this
            ->markRecentUnread($message)
            ->getCountersForUsers($message, $relations)
        ;
 
        return (new Result())->setResult(['COUNTERS' => $counters]);
    }
 
    public function onAfterNotificationSend(Message $message, Relation $relation): Result
    {
        $relationCollection = new RelationCollection();
        $relationCollection->add($relation);
        $this->counterService->addForEachUser($message, $relationCollection);
        $counter = $this->counterService->getByChat($relation->getChatId());
 
        return (new Result())->setResult(['COUNTER' => $counter]);
    }
 
    public function deleteByMessageId(int $messageId, ?array $invalidateCacheUsers = null): void
    {
        $this->counterService->deleteByMessageIdForAll($messageId, $invalidateCacheUsers);
        $this->viewedService->deleteByMessageIdForAll($messageId);
    }
 
    public function deleteByChatId(int $chatId): void
    {
        $this->counterService->deleteByChatId($chatId);
        $this->viewedService->deleteByChatId($chatId);
    }
 
    /*public function deleteByMessageIds(array $messageIds): void
    {
        $this->counterService->deleteByMessageIdsForAll($messageIds);
        $this->viewedController->deleteByMessageIdsForAll($messageIds);
    }*/
 
    public function getReadStatusesByMessageIds(array $messageIds): array
    {
        if (empty($messageIds))
        {
            return [];
        }
 
        $query = MessageUnreadTable::query()
            ->setSelect(['MESSAGE_ID'])
            ->whereIn('MESSAGE_ID', $messageIds)
            ->where('USER_ID', $this->getContext()->getUserId())
            ->exec()
        ; //todo add index
 
        $unreadMessages = [];
 
        while ($row = $query->fetch())
        {
            $unreadMessages[(int)$row['MESSAGE_ID']] = false;
        }
 
        $readStatuses = [];
 
        foreach ($messageIds as $messageId)
        {
            $readStatuses[$messageId] = $unreadMessages[$messageId] ?? true;
        }
 
        return $readStatuses;
    }
 
    public function getViewStatusesByMessageIds(array $messageIds): array
    {
        if (empty($messageIds))
        {
            return [];
        }
 
        $query = MessageViewedTable::query()
            ->setSelect(['MESSAGE_ID'])
            ->whereIn('MESSAGE_ID', $messageIds)
            ->where('USER_ID', $this->getContext()->getUserId())
            ->exec()
        ; //todo add index
 
        $viewedMessages = [];
 
        while ($row = $query->fetch())
        {
            $viewedMessages[(int)$row['MESSAGE_ID']] = true;
        }
 
        $viewStatuses = [];
 
        foreach ($messageIds as $messageId)
        {
            $viewStatuses[$messageId] = $viewedMessages[$messageId] ?? false;
        }
 
        return $viewStatuses;
    }
 
    public function getLastIdByChatId(int $chatId): int
    {
        $relation = RelationTable::query()
            ->setSelect(['LAST_ID'])
            ->where('USER_ID', $this->getContext()->getUserId())
            ->where('CHAT_ID', $chatId)->setLimit(1)
            ->fetch();
 
        if ($relation)
        {
            return $relation['LAST_ID'] ?? 0;
        }
 
        return 0;
    }
 
    public function getLastMessageIdInChat(int $chatId): int
    {
        if (isset(static::$lastMessageIdCache[$chatId]))
        {
            return static::$lastMessageIdCache[$chatId];
        }
 
        $result = ChatTable::query()->setSelect(['LAST_MESSAGE_ID'])->where('ID', $chatId)->fetch();
        $lastMessageId = 0;
 
        if (!$result)
        {
            $lastMessageId = 0;
        }
        else
        {
            $lastMessageId = (int)($result['LAST_MESSAGE_ID'] ?? 0);
        }
 
        static::$lastMessageIdCache[$chatId] = $lastMessageId;
 
        return $lastMessageId;
    }
 
    public function getChatMessageStatus(int $chatId): string
    {
        $lastMessageId = $this->getLastMessageIdInChat($chatId);
 
        if ($lastMessageId === 0)
        {
            return \IM_MESSAGE_STATUS_RECEIVED;
        }
 
        return $this->viewedService->getMessageStatus($lastMessageId);
    }
 
    public function getCounterService(): CounterService
    {
        return $this->counterService;
    }
 
    public function getViewedService(): ViewedService
    {
        return $this->viewedService;
    }
 
 
    public function setLastIdForRead(int $lastId, int $chatId): void
    {
        $sql = "
            UPDATE b_im_relation
            SET LAST_ID=(CASE WHEN LAST_ID > {$lastId} THEN LAST_ID ELSE {$lastId} END)
            WHERE CHAT_ID={$chatId} AND USER_ID={$this->getContext()->getUserId()}
        ";
 
        Application::getConnection()->queryExecute($sql);
    }
 
    public function setContext(?Context $context): self
    {
        $this->defaultSetContext($context);
        $this->getCounterService()->setContext($context);
        $this->getViewedService()->setContext($context);
 
        return $this;
    }
 
    private function setLastIdForReadAll(): void
    {
        $connection = Application::getConnection();
        $helper = $connection->getSqlHelper();
 
        $connection->queryExecute($helper->prepareCorrelatedUpdate(
            'b_im_relation',
            'R',
            [
                'LAST_ID' => 'C.LAST_MESSAGE_ID',
            ],
            ' b_im_chat C ',
            " C.ID = R.CHAT_ID AND R.MESSAGE_TYPE NOT IN ('" . IM_MESSAGE_OPEN_LINE . "', '" . IM_MESSAGE_SYSTEM . "')
                AND R.USER_ID = {$this->getContext()->getUserId()}"
        ));
    }
 
    private function updateDateRecent(int $chatId): void
    {
        $userId = $this->getContext()->getUserId();
        \Bitrix\Main\Application::getConnection()->query(
            "UPDATE b_im_recent SET DATE_UPDATE = NOW() WHERE USER_ID = {$userId} AND ITEM_CID = {$chatId}"
        );
    }
}