ChatAnalytics.php

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

<?php
 
declare(strict_types=1);
 
namespace Bitrix\Im\V2\Analytics;
 
use Bitrix\Disk\Analytics\DiskAnalytics;
use Bitrix\Disk\Analytics\Enum\ImSection;
use Bitrix\Disk\File;
use Bitrix\Im\V2\Analytics\Event\ChatEvent;
use Bitrix\Im\V2\Chat;
use Bitrix\Im\V2\Chat\CollabChat;
use Bitrix\Im\V2\Relation\Reason;
use Bitrix\Main\Loader;
 
class ChatAnalytics extends AbstractAnalytics
{
    public const SUBMIT_CREATE_NEW = 'submit_create_new';
 
    protected const JOIN = 'join';
    protected const ADD_DEPARTMENT = 'add_department';
    protected const ADD_USER = 'add_user';
    protected const DELETE_USER = 'delete_user';
    protected const FOLLOW_COMMENTS = 'follow_comments';
    protected const UNFOLLOW_COMMENTS = 'unfollow_comments';
    protected const EDIT_DESCRIPTION = 'edit_description';
    protected const DELETE_DEPARTMENT = 'delete_department';
    protected const EDIT_PERMISSIONS = 'edit_permissions';
    protected const SET_TYPE = 'set_type';
    protected const AUTODELETE_ON = 'autodelete_on';
    protected const AUTODELETE_OFF = 'autodelete_off';
 
    protected static array $oneTimeEvents = [];
    protected static array|bool $blockSingleUserEvents = [];
 
    public function addSubmitCreateNew(): void
    {
        $this->async(function () {
            $this
                ->createChatEvent(self::SUBMIT_CREATE_NEW)
                ?->setChatType()
                ?->send()
            ;
        });
    }
 
    public function addAddUser(Reason $reason = Reason::DEFAULT, bool $isJoin = false): void
    {
        if ($this->isSingleUserEventsBlocked())
        {
            return;
        }
 
        $this->async(function () use ($reason, $isJoin) {
            if ($isJoin)
            {
                $eventName = self::JOIN;
            }
            else
            {
                $eventName = match ($reason) {
                    Reason::STRUCTURE => self::ADD_DEPARTMENT,
                    default => self::ADD_USER,
                };
            }
 
            $this
                ->createChatEvent($eventName)
                ?->send()
            ;
            (new CopilotAnalytics($this->chat))->addAddUser();
        });
    }
 
    public function addDeleteUser(): void
    {
        if ($this->isSingleUserEventsBlocked())
        {
            return;
        }
 
        $this->async(function () {
            $this
                ->createChatEvent(self::DELETE_USER)
                ?->send()
            ;
            (new CopilotAnalytics($this->chat))->addDeleteUser();
        });
    }
 
    public function addFollowComments(bool $flag): void
    {
        $this->async(function () use ($flag) {
            $this
                ->createChatEvent($flag ? self::FOLLOW_COMMENTS : self::UNFOLLOW_COMMENTS)
                ?->send()
            ;
        });
    }
 
    public function addAutoDeleteOn(int $messagesAutoDeleteDelay): void
    {
        $this->async(function () use ($messagesAutoDeleteDelay) {
            $this
                ->createChatEvent(self::AUTODELETE_ON)
                ?->setP2(null)
                ->setP3('timer_' . $messagesAutoDeleteDelay)
                ->setP4(null)
                ->setP5(null)
                ->send()
            ;
        });
    }
 
    public function addAutoDeleteOff(): void
    {
        $this->async(function () {
            $this
                ->createChatEvent(self::AUTODELETE_OFF)
                ?->setP2(null)
                ->setP3(null)
                ->setP4(null)
                ->setP5(null)
                ->send()
            ;
        });
    }
 
    protected function addChatEditEvent(string $eventName): void
    {
        if ($this->chat instanceof CollabChat)
        {
            return;
        }
 
        $this->async(function () use ($eventName) {
            $this
                ->createChatEvent($eventName)
                ?->send()
            ;
        });
    }
 
    public function addEditDescription(): void
    {
        $this->async(function () {
            $this
                ->createChatEvent(self::EDIT_DESCRIPTION)
                ?->send()
            ;
        });
    }
 
    public function addAddDepartment(): void
    {
        $this->addChatEditEvent(self::ADD_DEPARTMENT);
    }
 
    public function addDeleteDepartment(): void
    {
        $this->addChatEditEvent(self::DELETE_DEPARTMENT);
    }
 
    public function addEditPermissions(): void
    {
        if ($this->isFirstTimeEvent(self::EDIT_PERMISSIONS))
        {
            $this->addChatEditEvent(self::EDIT_PERMISSIONS);
        }
    }
 
    public function addSetType(): void
    {
        $this->addChatEditEvent(self::SET_TYPE);
    }
 
    public function addUploadFile(File $file): void
    {
        if (Loader::includeModule('disk'))
        {
            $this->async(fn () => DiskAnalytics::sendUploadFileToImEvent($file, $this->getImSectionForDiskEvent()));
        }
    }
 
    protected function getImSectionForDiskEvent(): ImSection
    {
        return match ($this->chat->getType())
        {
            Chat::IM_TYPE_CHANNEL, Chat::IM_TYPE_OPEN_CHANNEL => ImSection::Channel,
            Chat::IM_TYPE_OPEN_LINE => ImSection::Openline,
            default => ImSection::Chat
        };
    }
 
    protected function createChatEvent(
        string $eventName,
    ): ?ChatEvent
    {
        if (!$this->isChatTypeAllowed($this->chat))
        {
            return null;
        }
 
        return (new ChatEvent($eventName, $this->chat, $this->userId));
    }
 
    protected function isFirstTimeEvent(string $eventName): bool
    {
        $result = self::$oneTimeEvents[$eventName][$this->chat->getId()] ?? true;
        self::$oneTimeEvents[$eventName][$this->chat->getId()] = false;
 
        return $result;
    }
 
    public static function blockSingleUserEvents(?Chat $chat = null): void
    {
        if (self::$blockSingleUserEvents === true)
        {
            return;
        }
 
        if ($chat === null)
        {
            self::$blockSingleUserEvents = true;
 
            return;
        }
 
        self::$blockSingleUserEvents[$chat->getId()] = true;
    }
 
    public static function unblockSingleUserEventsByChat(Chat $chat): void
    {
        if (is_bool(self::$blockSingleUserEvents))
        {
            return;
        }
 
        unset(self::$blockSingleUserEvents[$chat->getId()]);
    }
 
    protected function isSingleUserEventsBlocked(): bool
    {
        if (!is_array(self::$blockSingleUserEvents))
        {
            return true;
        }
 
        return self::$blockSingleUserEvents[$this->chat->getId()] ?? false;
    }
}