workgroup.php

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

<?php
 
namespace Bitrix\Socialnetwork\Controller;
 
use Bitrix\Intranet\Integration\Templates\Bitrix24\ThemePicker;
use Bitrix\Intranet\Internals\ThemeTable;
use Bitrix\Main\Context;
use Bitrix\Main\Engine;
use Bitrix\Main\Engine\Controller;
use Bitrix\Main\Entity\Query;
use Bitrix\Main\Error;
use Bitrix\Main\Loader;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\ModuleManager;
use Bitrix\Main\Type\DateTime;
use Bitrix\Main\UI\PageNavigation;
use Bitrix\Main\UserTable;
use Bitrix\Socialnetwork\Collab\Integration\IM\Dialog;
use Bitrix\Socialnetwork\EO_UserToGroup;
use Bitrix\Socialnetwork\Helper;
use Bitrix\Socialnetwork\Helper\AvatarManager;
use Bitrix\Socialnetwork\Integration\Im\Chat;
use Bitrix\Socialnetwork\Integration\Main\File;
use Bitrix\Socialnetwork\Integration\Pull\PushService;
use Bitrix\Socialnetwork\Internals\Counter;
use Bitrix\Socialnetwork\Internals\Counter\CounterDictionary;
use Bitrix\Socialnetwork\Internals\EventService\EventDictionary;
use Bitrix\Socialnetwork\Internals\EventService\Push\PushEventDictionary;
use Bitrix\Socialnetwork\Internals\EventService\Service;
use Bitrix\Socialnetwork\Item\Subscription;
use Bitrix\Socialnetwork\Item\WorkgroupFavorites;
use Bitrix\Socialnetwork\Provider\GroupProvider;
use Bitrix\Socialnetwork\Space\MembersManager;
use Bitrix\Socialnetwork\Space\Toolbar\Switcher\Option\Pin;
use Bitrix\Socialnetwork\UserToGroupTable;
use Bitrix\Socialnetwork\WorkgroupPinTable;
use Bitrix\Socialnetwork\WorkgroupSiteTable;
use Bitrix\Socialnetwork\WorkgroupSubjectTable;
use Bitrix\Socialnetwork\WorkgroupTable;
use Bitrix\Socialnetwork\WorkgroupTagTable;
use Bitrix\Tasks\Internals\Effective;
use CExtranet;
use Exception;
 
class Workgroup extends Base
{
    private static function getAllowedSelectFields(): array
    {
        return [
            'ID', 'ACTIVE', 'SUBJECT_ID', 'NAME', 'DESCRIPTION', 'KEYWORDS',
            'CLOSED', 'VISIBLE', 'OPENED', 'PROJECT', 'LANDING',
            'DATE_CREATE', 'DATE_UPDATE', 'DATE_ACTIVITY',
            'IMAGE_ID', 'AVATAR_TYPE',
            'OWNER_ID',
            'NUMBER_OF_MEMBERS', 'NUMBER_OF_MODERATORS',
            'INITIATE_PERMS',
            'PROJECT_DATE_START', 'PROJECT_DATE_FINISH',
            'SCRUM_OWNER_ID', 'SCRUM_MASTER_ID', 'SCRUM_SPRINT_DURATION', 'SCRUM_TASK_RESPONSIBLE',
            'TYPE',
        ];
    }
 
    public function getAction(array $params = []): ?array
    {
        $groupId = (int)($params['groupId'] ?? 0);
 
        if ($groupId <= 0)
        {
            $this->addEmptyGroupIdError();
            return null;
        }
 
        $select = (array)($params['select'] ?? []);
        $filter = (array)($params['filter'] ?? []);
        $filter['ID'] = $groupId;
 
        if (!\CSocNetUser::isCurrentUserModuleAdmin(SITE_ID, false))
        {
            $filter['CHECK_PERMISSIONS'] = $this->getCurrentUser()->getId();
        }
 
        $result = \CSocNetGroup::getList([], $filter, false, false, ['ID']);
        if ($group = $result->fetch())
        {
            $groupItem = \Bitrix\Socialnetwork\Item\Workgroup::getById($group['ID']);
            $groupFields = $groupItem->getFields();
 
            if (in_array('DATE_CREATE', $select, true))
            {
                $culture = Context::getCurrent()->getCulture();
                $longDateFormat = $culture->getLongDateFormat();
                $shortTimeFormat = $culture->getShortTimeFormat();
 
                $groupFields['DATE_CREATE'] = \CComponentUtil::getDateTimeFormatted([
                    'TIMESTAMP' => MakeTimeStamp($groupFields['DATE_CREATE']),
                    'TZ_OFFSET' => \CTimeZone::getOffset(),
                ], "$longDateFormat, $shortTimeFormat");
            }
            if (in_array('AVATAR', $select, true))
            {
                $groupFields['AVATAR'] = File::getFileSource((int)$groupFields['IMAGE_ID'], 100, 100);
            }
            if (in_array('AVATAR_TYPES', $select, true))
            {
                $groupFields['AVATAR_TYPES'] = Helper\Workgroup::getAvatarTypes();
            }
            if (in_array('AVATAR_DATA', $select, true))
            {
                $imageId = (int) $groupFields['IMAGE_ID'];
                $avatarType = $groupFields['AVATAR_TYPE'] ?? '';
                $groupFields['AVATAR_DATA'] = $this->getAvatarData($imageId, $avatarType);
            }
            if (in_array('OWNER_DATA', $select, true))
            {
                $groupFields['OWNER_DATA'] = $this->getOwnerData($groupFields['OWNER_ID']);
            }
            if (in_array('SUBJECT_DATA', $select, true))
            {
                $groupFields['SUBJECT_DATA'] = $this->getSubjectData($groupFields['SUBJECT_ID']);
            }
            if (in_array('TAGS', $select, true))
            {
                $groupFields['TAGS'] = $this->getTags($groupId);
            }
            if (in_array('THEME_DATA', $select, true))
            {
                $groupFields['THEME_DATA'] = $this->getThemeData($groupId);
            }
            if (in_array('ACTIONS', $select, true))
            {
                $groupFields['ACTIONS'] = $this->getActions($groupId);
            }
            if (in_array('USER_DATA', $select, true))
            {
                $groupFields['USER_DATA'] = $this->getUserData($groupId);
            }
            if (in_array('DEPARTMENTS', $select, true))
            {
                $groupFields['DEPARTMENTS'] = $this->getDepartments($groupFields['UF_SG_DEPT']['VALUE']);
            }
            if (in_array('PIN', $select, true))
            {
                $groupFields['IS_PIN'] = $this->isPin($groupId, $this->getCurrentUser()->getId());
            }
            if (in_array('PRIVACY_TYPE', $select, true))
            {
                $groupFields['PRIVACY_CODE'] = Helper\Workgroup::getConfidentialityTypeCodeByParams([
                    'fields' => [
                        'OPENED' => $groupFields['OPENED'],
                        'VISIBLE' => $groupFields['VISIBLE'],
                    ],
                ]);
            }
            if (in_array('LIST_OF_MEMBERS', $select, true))
            {
                $groupFields['LIST_OF_MEMBERS'] = $this->getListOfMembers(
                    $groupId,
                    $groupItem->getScrumMaster()
                );
            }
            if (in_array('FEATURES', $select, true))
            {
                $groupFields['FEATURES'] = $this->prepareFeatures($groupId);
            }
            $needListOfAwaiting = in_array('LIST_OF_MEMBERS_AWAITING_INVITE', $select, true);
            $needMembersList = in_array('GROUP_MEMBERS_LIST', $select, true);
            if ($needListOfAwaiting || $needMembersList)
            {
                $permissions = Helper\Workgroup::getPermissions(
                    ['groupId' => $groupId],
                );
            }
            if ($needListOfAwaiting)
            {
                $groupFields['LIST_OF_MEMBERS_AWAITING_INVITE'] = [];
                if ($permissions['UserCanModifyGroup'] || $permissions['UserCanInitiate'])
                {
                    $groupFields['LIST_OF_MEMBERS_AWAITING_INVITE'] = $this->getListOfAwaitingMembers($groupId);
                }
            }
            if ($needMembersList)
            {
                $groupFields['GROUP_MEMBERS_LIST'] = [];
                if ($permissions['UserCanModifyGroup'] || $permissions['UserCanInitiate'])
                {
                    $membersManager = new MembersManager();
                    $groupFields['GROUP_MEMBERS_LIST'] = $membersManager->getGroupMembersList($groupId);
                }
            }
 
            if (in_array('COUNTERS', $select, true))
            {
                $groupFields['COUNTERS'] = $this->getCounters($groupId);
            }
 
            if ($groupFields['NUMBER_OF_MEMBERS'])
            {
                $groupFields['NUMBER_OF_MEMBERS_PLURAL'] = Loc::getPluralForm($groupFields['NUMBER_OF_MEMBERS']);
            }
            if ($groupFields['PROJECT_DATE_START'] || $groupFields['PROJECT_DATE_FINISH'])
            {
                $culture = Context::getCurrent()->getCulture();
                $format = $culture->getDayMonthFormat();

                $dateStart = $groupFields['PROJECT_DATE_START'];
                $dateFinish = $groupFields['PROJECT_DATE_FINISH'];
 
                if ($dateStart)
                {
                    $groupFields['FORMATTED_PROJECT_DATE_START'] = FormatDate(
                        $format,
                        MakeTimeStamp(DateTime::createFromTimestamp($dateStart->getTimestamp()))
                    );
                }
                if ($dateFinish)
                {
                    $groupFields['FORMATTED_PROJECT_DATE_FINISH'] = FormatDate(
                        $format,
                        MakeTimeStamp(DateTime::createFromTimestamp($dateFinish->getTimestamp()))
                    );
                }
            }
 
            if (
                isset($params['mode'])
                && $params['mode'] === 'mobile'
            )
            {
                $additionalData = Helper\Workgroup::getAdditionalData([
                    'ids' => [ $groupId ],
                    'features' => ($params['features'] ?? []),
                    'mandatoryFeatures' => ($params['mandatoryFeatures'] ?? []),
                    'currentUserId' => (int)$this->getCurrentUser()->getId(),
                ]);
 
                $groupFields['ADDITIONAL_DATA'] = ($additionalData[$groupId] ?? []) ;
            }
 
            $isScrum = !empty($groupFields['SCRUM_MASTER_ID']);
            if (!$isScrum && in_array('EFFICIENCY', $select, true) && Loader::includeModule('tasks'))
            {
                $efficiencies = Effective::getAverageEfficiencyForGroups(
                    null,
                    null,
                    0,
                    [$group['ID']],
                );
 
                $groupFields['EFFICIENCY'] = $efficiencies[$group['ID']] ?? null;
            }
 
            return $groupFields;
        }
 
        $this->addError(
            new Error(
                Loc::getMessage('SONET_CONTROLLER_WORKGROUP_NOT_FOUND'),
                'SONET_CONTROLLER_WORKGROUP_NOT_FOUND'
            )
        );
 
        return null;
    }
 
    public function listAction(
        PageNavigation $pageNavigation,
        array $filter = [],
        array $select = [],
        array $order = [],
        array $params = []
    )
    {
        if (
            empty($select)
            || !is_array($select)
        )
        {
            $select = [ 'ID' ];
        }
 
        if (!in_array('ID', $select, true))
        {
            $select[] = 'ID';
        }
 
        $originalSelect = $select;
 
        if (
            $params['IS_ADMIN'] === 'Y'
            && !\CSocNetUser::isCurrentUserModuleAdmin(SITE_ID, false)
        )
        {
            unset($params['IS_ADMIN']);
        }
 
        if ($params['IS_ADMIN'] !== 'Y')
        {
            $filter['CHECK_PERMISSIONS'] = $this->getCurrentUser()->getId();
        }
 
        $extranetSiteId = \CSocNetLogRestService::getExtranetSiteId();
 
        if (
            $extranetSiteId
            && $params['IS_ADMIN'] !== 'Y'
            && \CSocNetLogRestService::getCurrentUserType() === 'extranet'
        )
        {
            $filter['SITE_ID'] = $extranetSiteId;
        }
        else
        {
            $filter['SITE_ID'] = (string)($params['siteId'] ?? SITE_ID);
        }
 
        if (($key = array_search('AVATAR', $select, true)) !== false)
        {
            $select[] = 'IMAGE_ID';
            $select[] = 'AVATAR_TYPE';
            unset($select[$key]);
        }
 
        $workgroups = [];
        $count = 0;
 
        $queryIdFilter = [];
 
        $res = \CSocNetGroup::getList([], $filter, false, false, [ 'ID' ]);
        while ($groupFields = $res->fetch())
        {
            $queryIdFilter[] = (int)$groupFields['ID'];
        }
 
        if (!empty($queryIdFilter))
        {
            $select = $this->prepareSelect($select);
 
            $query = WorkgroupTable::query();
            $query
                ->setSelect($select)
                ->setOrder($order)
                ->setOffset($pageNavigation->getOffset())
                ->setLimit(($pageNavigation->getLimit()))
                ->setFilter([
                    'ID' => $queryIdFilter,
                ])
                ->countTotal(true);
 
            $res = $query->exec();
 
            $avatarTypes = Helper\Workgroup::getAvatarTypes();
 
            while ($groupFields = $res->fetch())
            {
                if (in_array('AVATAR', $originalSelect, true))
                {
                    if ((int)$groupFields['IMAGE_ID'] > 0)
                    {
                        $groupFields['AVATAR'] = File::getFileSource((int)$groupFields['IMAGE_ID'], 100, 100);
                    }
                    elseif (
                        !empty($groupFields['AVATAR_TYPE'])
                        && isset($params['mode'])
                        && $params['mode'] === 'mobile'
                    )
                    {
                        $groupFields['AVATAR'] = $avatarTypes[$groupFields['AVATAR_TYPE']]['mobileUrl'];
                    }
                    else
                    {
                        $groupFields['AVATAR'] = '';
                    }
                }
 
                $workgroups[(int)$groupFields['ID']] = $groupFields;
            }
 
            $count = $res->getCount();
        }
 
        $ids = array_keys($workgroups);
 
        if (
            isset($params['mode'])
            && $params['mode'] === 'mobile'
        )
        {
            $additionalData = Helper\Workgroup::getAdditionalData([
                'ids' => $ids,
                'features' => ($params['features'] ?? []),
                'mandatoryFeatures' => ($params['mandatoryFeatures'] ?? []),
                'currentUserId' => (int)$this->getCurrentUser()->getId(),
            ]);
 
            foreach (array_keys($workgroups) as $id)
            {
                if (!isset($additionalData[$id]))
                {
                    continue;
                }
 
                $workgroups[$id]['ADDITIONAL_DATA'] = ($additionalData[$id] ?? []) ;
            }
        }
 
        if (($params['shouldSelectDialogId'] ?? 'N') === 'Y')
        {
            $chatData = Chat\Workgroup::getChatData([
                'group_id' => $ids,
                'skipAvailabilityCheck' => true,
            ]);
 
            foreach ($workgroups as $id => $fields)
            {
                $workgroups[$id]['DIALOG_ID'] = Dialog::getDialogId($chatData[$id] ?? 0);
            }
        }
 
        $workgroups = $this->convertKeysToCamelCase($workgroups);
 
        return new Engine\Response\DataType\Page('workgroups', array_values($workgroups), $count);
    }

    public function isExistingGroupAction(string $name): array
    {
        return [
            'exists' => GroupProvider::getInstance()->isExistingGroup($name),
        ];
    }
 
    private function prepareSelect(array $select = []): array
    {
        return array_filter($select, static function ($key) {
            return in_array(mb_strtoupper($key), static::getAllowedSelectFields(), true);
        });
    }
 
    private function getAvatarData(int $imageId, string $avatarType): array
    {
        $avatarManager = new AvatarManager();
 
        if ($imageId)
        {
            $avatarData = $avatarManager->getImageAvatar($imageId)->toArray();
        }
        else
        {
            $avatarData = $avatarManager->getIconAvatar($avatarType)->toArray();
        }
 
        return $avatarData;
    }
 
    private function getOwnerData(int $ownerId): array
    {
        $owner = UserTable::getList([
            'select' => ['NAME', 'LAST_NAME', 'SECOND_NAME', 'LOGIN', 'PERSONAL_PHOTO'],
            'filter' => ['ID' => $ownerId],
        ])->fetch();
 
        return [
            'ID' => $ownerId,
            'PHOTO' => ($owner['PERSONAL_PHOTO'] ? File::getFileSource($owner['PERSONAL_PHOTO']) : null),
            'FORMATTED_NAME' => htmlspecialcharsback(
                \CUser::FormatName(
                    \CSite::getNameFormat(),
                    [
                        'NAME' => $owner['NAME'],
                        'LAST_NAME' => $owner['LAST_NAME'],
                        'SECOND_NAME' => $owner['SECOND_NAME'],
                        'LOGIN' => $owner['LOGIN'],
                    ],
                    true
                )
            ),
        ];
    }
 
    private function getSubjectData(int $subjectId): array
    {
        $subject = WorkgroupSubjectTable::getList([
            'select' => ['NAME'],
            'filter' => ['ID' => $subjectId],
        ])->fetch();
 
        return [
            'ID' => $subjectId,
            'NAME' => $subject['NAME'],
        ];
    }
 
    private function getTags(int $groupId): array
    {
        $tags = WorkgroupTagTable::getList([
            'select' => ['NAME'],
            'filter' => ['GROUP_ID' => $groupId],
        ])->fetchAll();
 
        return array_map(
            static function($tag) {
                return htmlspecialcharsback($tag);
            },
            array_column($tags, 'NAME')
        );
    }
 
    private function getThemeData(int $groupId): ?array
    {
        if (!Loader::includeModule('intranet'))
        {
            return [];
        }
 
        $themePicker = new ThemePicker(
            SITE_TEMPLATE_ID,
            false,
            $this->getCurrentUser()->getId(),
            ThemePicker::ENTITY_TYPE_SONET_GROUP,
            $groupId
        );
 
        $themeUserId = false;
        $themeId = $themePicker->getCurrentThemeId();
        if ($themeId)
        {
            $res = ThemeTable::getList([
                'select' => ['USER_ID'],
                'filter' => [
                    '=ENTITY_TYPE' => $themePicker->getEntityType(),
                    'ENTITY_ID' => $themePicker->getEntityId(),
                    '=CONTEXT' => $themePicker->getContext(),
                ],
            ]);
            if (($themeFields = $res->fetch()) && (int)$themeFields['USER_ID'] > 0)
            {
                $themeUserId = (int)$themeFields['USER_ID'];
            }
        }
 
        return $themePicker->getTheme($themeId, $themeUserId);
    }
 
    private function getActions(int $groupId): array
    {
        $permissions = Helper\Workgroup::getPermissions(['groupId' => $groupId]);
 
        $canEditFeatures = $permissions['UserCanModifyGroup'];
        if (!\Bitrix\Socialnetwork\Helper\Workgroup::getEditFeaturesAvailability())
        {
            $canEditFeatures = false;
        }
 
        return [
            'EDIT' => $permissions['UserCanModifyGroup'],
            'DELETE' => $permissions['UserCanModifyGroup'],
            'INVITE' => $permissions['UserCanInitiate'],
            'JOIN' => (
                !$permissions['UserIsMember']
                && !$permissions['UserRole']
            ),
            'LEAVE' => (
                $permissions['UserIsMember']
                && !$permissions['UserIsAutoMember']
                && !$permissions['UserIsOwner']
                && !$permissions['UserIsScrumMaster']
            ),
            'FOLLOW' => $permissions['UserIsMember'],
            'PIN' => $permissions['UserIsMember'],
            'EDIT_FEATURES' => $canEditFeatures,
        ];
    }
 
    private function getUserData(int $groupId): array
    {
        $permissions = Helper\Workgroup::getPermissions(['groupId' => $groupId]);
 
        return [
            'ROLE' => $permissions['UserRole'],
            'INITIATED_BY_TYPE' => $permissions['InitiatedByType'],
            'IS_SUBSCRIBED' => (
                in_array($permissions['UserRole'], UserToGroupTable::getRolesMember(), true)
                && \CSocNetSubscription::isUserSubscribed($this->getCurrentUser()->getId(), 'SG' . $groupId)
            ),
        ];
    }
 
    private function getDepartments($ufDepartments): array
    {
        $departments = [];
 
        if (
            empty($ufDepartments)
            || !is_array($ufDepartments)
            || !Loader::includeModule('intranet')
        )
        {
            return $departments;
        }
 
        $departmentsList = \CIntranetUtils::getDepartmentsData($ufDepartments);
        if (empty($departmentsList))
        {
            return $departments;
        }
 
        foreach ($departmentsList as $id => $name)
        {
            if (($id = (int)$id) <= 0)
            {
                continue;
            }
 
            $departments[] = [
                'ID' => $id,
                'NAME' => $name,
            ];
        }
 
        return $departments;
    }
 
    private function isPin(int $groupId, int $currentUserId, string $context = ''): bool
    {
        $query = new Query(WorkgroupPinTable::getEntity());
 
        $query = $query
            ->setSelect([
                'ID',
                'GROUP_ID',
                'USER_ID',
            ])
            ->where('GROUP_ID', $groupId)
            ->where('USER_ID', $currentUserId)
        ;
        if ($context === '')
        {
            $query = $query->where(Query::filter()
                ->logic('or')
                ->whereNull('CONTEXT')
                ->where('CONTEXT', '')
            );
        }
        else
        {
            $query = $query->where('CONTEXT', $context);
        }
 
        $pin = $query->setLimit(1)->exec()->fetchObject();
 
        return (bool) $pin;
    }
 
    private function getListOfMembers(int $groupId, int $scrumMasterId): array
    {
        $list = [];
 
        $records = UserToGroupTable::query()
            ->setSelect([
                'GROUP_ID',
                'USER_ID',
                'ROLE',
                'INITIATED_BY_TYPE',
                'AUTO_MEMBER',
                'NAME' => 'USER.NAME',
                'LAST_NAME' => 'USER.LAST_NAME',
                'SECOND_NAME' => 'USER.SECOND_NAME',
                'WORK_POSITION' => 'USER.WORK_POSITION',
                'LOGIN' => 'USER.LOGIN',
                'PERSONAL_PHOTO' => 'USER.PERSONAL_PHOTO',
            ])
            ->whereIn('GROUP_ID', $groupId)
            ->whereIn('ROLE', UserToGroupTable::getRolesMember())
            ->exec()->fetchCollection()
        ;
 
        $members = [];
        $imageIdList = [];
        foreach ($records as $record)
        {
            $user = $record->get('USER');
            $imageIdList[$record->get('USER_ID')] = $user->get('PERSONAL_PHOTO');
            $members[] = $record;
        }
        $imageIdList = array_filter(
            $imageIdList,
            static function ($id) {
                return (int) $id > 0;
            }
        );
        $avatars = $this->getUserAvatars($imageIdList);
 
        foreach ($members as $member)
        {
            $memberId = (int) $member['USER_ID'];
 
            $isOwner = ($member['ROLE'] === UserToGroupTable::ROLE_OWNER);
            $isModerator = ($member['ROLE'] === UserToGroupTable::ROLE_MODERATOR);
            $isScrumMaster = ($scrumMasterId === $memberId);
            $memberUser = $member->getUser();
 
            $list[] = [
                'id' => $memberId,
                'isOwner' => $isOwner,
                'isModerator' => $isModerator,
                'isScrumMaster' => $isScrumMaster,
                'isAutoMember' => $member['AUTO_MEMBER'],
                'name' => $memberUser->getName(),
                'lastName' => $memberUser->getLastName(),
                'position' => $memberUser->getWorkPosition(),
                'photo' => ($avatars[($imageIdList[$memberId] ?? '')] ?? ''),
            ];
        }
 
        return $list;
    }
 
    private function prepareFeatures(int $groupId): array
    {
        $features = [];
 
        $baseFeatures = $this->getBaseFeatures($groupId);
 
        foreach ($this->getAllowedFeatures() as $featureId => $feature)
        {
            if (array_key_exists($featureId, $baseFeatures))
            {
                $features[] = [
                    'featureName' => $featureId,
                    'name' => Loc::getMessage('SOCIALNETWORK_WORKGROUP_'.strtoupper($featureId)),
                    'customName' => $baseFeatures[$featureId]['FEATURE_NAME'] ?? '',
                    'id' => $baseFeatures[$featureId]['ID'],
                    'active' => $baseFeatures[$featureId]['ACTIVE'] === 'Y',
                ];
            }
        }
 
        return $features;
    }
 
    private function getBaseFeatures(int $groupId): array
    {
        $features = [];
 
        $queryObject = \CSocNetFeatures::getList(
            [],
            [
                'ENTITY_ID' => $groupId,
                'ENTITY_TYPE' => SONET_ENTITY_GROUP,
            ]
        );
        while ($featureFields = $queryObject->fetch())
        {
            $features[$featureFields['FEATURE']]= $featureFields;
        }
 
        return $features;
    }
 
    private function getAllowedFeatures(): array
    {
        $allowedFeatures = \CSocNetAllowed::getAllowedFeatures();
 
        $sampleKeysList = [
            'tasks' => 1,
            'calendar' => 2,
            'files' => 3,
            'chat' => 4,
            'forum' => 5,
            'microblog' => 6,
            'blog' => 7,
            'photo' => 8,
            'group_lists' => 9,
            'wiki' => 10,
            'content_search' => 11,
            'marketplace' => 12,
        ];
 
        uksort($allowedFeatures, static function($a, $b) use ($sampleKeysList) {
 
            $valA = ($sampleKeysList[$a] ?? 100);
            $valB = ($sampleKeysList[$b] ?? 100);
 
            if ($valA > $valB)
            {
                return 1;
            }
 
            if ($valA < $valB)
            {
                return -1;
            }
 
            return 0;
        });
 
        return array_filter($allowedFeatures, function($feature) {
            return (
                is_array($feature['allowed'])
                && in_array(SONET_ENTITY_GROUP, $feature['allowed'], true)
            );
        });
    }
 
    private function getListOfAwaitingMembers(int $groupId, int $limit = 10, int $offset = 0): array
    {
        $list = [];
 
        $records = UserToGroupTable::query()
            ->setSelect([
                'GROUP_ID',
                'USER_ID',
                'ROLE',
                'INITIATED_BY_TYPE',
                'NAME' => 'USER.NAME',
                'LAST_NAME' => 'USER.LAST_NAME',
                'SECOND_NAME' => 'USER.SECOND_NAME',
                'LOGIN' => 'USER.LOGIN',
                'PERSONAL_PHOTO' => 'USER.PERSONAL_PHOTO',
            ])
            ->whereIn('GROUP_ID', $groupId)
            ->where('INITIATED_BY_TYPE', UserToGroupTable::INITIATED_BY_USER)
            ->where('ROLE', UserToGroupTable::ROLE_REQUEST)
            ->setLimit($limit)
            ->setOffset($offset)
            ->exec()->fetchCollection()
        ;
 
        $members = [];
        $imageIdList = [];
        foreach ($records as $record)
        {
            $user = $record->get('USER');
            $imageIdList[$record->get('USER_ID')] = $user->get('PERSONAL_PHOTO');
 
            $members[] = $record;
        }
        $imageIdList = array_filter(
            $imageIdList,
            static function ($id) {
                return (int) $id > 0;
            }
        );
        $avatars = $this->getUserAvatars($imageIdList);
 
        foreach ($members as $member)
        {
            $memberId = (int) $member['USER_ID'];
 
            $userNameFormatted = \CUser::formatName(\CSite::getNameFormat(), [
                'NAME' => $member->get('USER')->get('NAME'),
                'LAST_NAME' => $member->get('USER')->get('LAST_NAME'),
                'SECOND_NAME' => $member->get('USER')->get('SECOND_NAME'),
                'LOGIN' => $member->get('USER')->get('LOGIN'),
            ], ModuleManager::isModuleInstalled('intranet'));
 
            $list[] = [
                'id' => $memberId,
                'name' => $userNameFormatted,
                'photo' => ($avatars[($imageIdList[$memberId] ?? '')] ?? ''),
            ];
        }
 
        return $list;
    }
 
    private function getCounters(int $groupId): array
    {
        $counters = [];
 
        $counterProvider = Counter::getInstance($this->getCurrentUser()->getId());
 
        $availableCounters = [
            CounterDictionary::COUNTER_WORKGROUP_REQUESTS_OUT,
            CounterDictionary::COUNTER_WORKGROUP_REQUESTS_IN,
        ];
        foreach ($availableCounters as $counter)
        {
            $counters[$counter] = $counterProvider->get($counter, $groupId)['all'];
        }
 
        return $counters;
    }
 
    public function updateAction(int $groupId, array $fields = []): ?bool
    {
        if (!Helper\Workgroup\Access::canModify([
            'groupId' => $groupId,
            'checkAdminSession' => ($this->getScope() !== Controller::SCOPE_REST),
        ]))
        {
            $this->addEmptyGroupIdError();
            return null;
        }
 
        $whiteList = [
            'NAME',
            'DESCRIPTION',
            'KEYWORDS',
            'VISIBLE',
            'OPENED',
            'EXTERNAL',
        ];
 
        foreach ($fields as $key => $value)
        {
            if (!in_array($key, $whiteList, true))
            {
                unset($fields[$key]);
            }
        }
 
        if (
            empty($fields)
        )
        {
            $this->addError(new Error(
                Loc::getMessage('SONET_CONTROLLER_WORKGROUP_ACTION_FAILED'),
                'SONET_CONTROLLER_WORKGROUP_ACTION_FAILED')
            );
            return null;
        }
 
        try
        {
            $result = \CSocNetGroup::update($groupId, $fields);
        }
        catch (Exception $e)
        {
            $this->addError(new Error($e->getMessage(), $e->getCode()));
            return null;
        }
 
        if (!$result)
        {
            $this->addError(new Error(
                Loc::getMessage('SONET_CONTROLLER_WORKGROUP_ACTION_FAILED'),
                'SONET_CONTROLLER_WORKGROUP_ACTION_FAILED')
            );
            return null;
        }
 
        $this->sendPush(PushEventDictionary::EVENT_WORKGROUP_UPDATE, [
            'params' => [
                'GROUP_ID' => $groupId,
            ],
        ]);
 
        return true;
    }
 
    public function leaveAction(int $groupId)
    {
        if (!Helper\Workgroup\Access::canLeave([ 'groupId' => $groupId ]))
        {
            $this->addError(new Error('NO PERMISSION'));
            return null;
        }
 
        return \CSocNetUserToGroup::DeleteRelation($this->userId, $groupId);
    }
 
    public function deleteAction(int $groupId)
    {
        if (
            !Helper\Workgroup\Access::canModify([
                'groupId' => $groupId,
                'checkAdminSession' => ($this->getScope() !== Controller::SCOPE_REST),
            ])
        )
        {
            $this->addEmptyGroupIdError();
 
            return null;
        }
 
        global $APPLICATION;
 
        $deleteResult = \CSocNetGroup::Delete($groupId);
        if (!$deleteResult && ($e = $APPLICATION->GetException()))
        {
            return $e->GetString();
        }
 
        return true;
    }
 
    public function getAvatarTypesAction(): array
    {
        return Helper\Workgroup::getAvatarTypes();
    }
 
    public function disconnectDepartmentsAction(int $groupId, array $departmentIds)
    {
        foreach ($departmentIds as $id)
        {
            Helper\Workgroup::disconnectDepartment([
                'groupId' => $groupId,
                'departmentId' => $id,
            ]);
        }
    }
 
    public function setFavoritesAction(array $params = []): ?array
    {
        $groupId = (int)($params['groupId'] ?? 0);
        $getAdditionalResultData = (bool)($params['getAdditionalResultData'] ?? false);
 
        if ($groupId <= 0)
        {
            $this->addEmptyGroupIdError();
            return null;
        }
 
        if (!in_array($params['value'] ?? null, WorkgroupFavorites::AVAILABLE_VALUES, true))
        {
            $this->addIncorrectValueError();
            return null;
        }
 
        try
        {
            $res = WorkgroupFavorites::set([
                'GROUP_ID' => $groupId,
                'USER_ID' => $this->getCurrentUser()->getId(),
                'VALUE' => $params['value'],
            ]);
        }
        catch (Exception $e)
        {
            $this->addError(new Error($e->getMessage(), $e->getCode()));
            return null;
        }
 
        if (!$res)
        {
            $this->addError(new Error(Loc::getMessage('SONET_CONTROLLER_WORKGROUP_ACTION_FAILED'), 'SONET_CONTROLLER_WORKGROUP_ACTION_FAILED'));
            return null;
        }
 
        $result = [
            'ID' => $groupId,
            'RESULT' => $params['value'],
        ];
 
        if ($getAdditionalResultData)
        {
            $groupItem = \Bitrix\Socialnetwork\Item\Workgroup::getById($groupId);
            $groupFields = $groupItem->getFields();
            $groupUrlData = $groupItem->getGroupUrlData([
                'USER_ID' => $this->getCurrentUser()->getId(),
            ]);
 
            $groupSiteList = [];
            $resSite = WorkgroupSiteTable::getList([
                'filter' => [
                    '=GROUP_ID' => $groupId
                ],
                'select' => [ 'SITE_ID' ],
            ]);
            while ($groupSite = $resSite->fetch())
            {
                $groupSiteList[] = $groupSite['SITE_ID'];
            }
 
            $result['NAME'] = $groupFields['NAME'];
            $result['URL'] = $groupUrlData["URL"];
            $result['EXTRANET'] = (
            Loader::includeModule('extranet')
            && CExtranet::isIntranetUser()
            && in_array(CExtranet::getExtranetSiteId(), $groupSiteList, true)
                ? 'Y'
                : 'N'
            );
        }
 
        $this->sendPush(PushEventDictionary::EVENT_WORKGROUP_FAVORITES_CHANGED, ['GROUP_ID' => $groupId]);
 
        return $result;
    }
 
    public function setSubscriptionAction(array $params = []): ?array
    {
        $groupId = (int)($params['groupId'] ?? 0);
        if ($groupId <= 0)
        {
            $this->addEmptyGroupIdError();
            return null;
        }
 
        if (!in_array($params['value'] ?? null, Subscription::AVAILABLE_VALUES, true))
        {
            $this->addIncorrectValueError();
            return null;
        }
 
        try
        {
            $result = Subscription::set([
                'GROUP_ID' => $groupId,
                'USER_ID' => $this->getCurrentUser()->getId(),
                'VALUE' => $params['value'],
            ]);
        }
        catch (Exception $e)
        {
            $this->addError(new Error($e->getMessage(), $e->getCode()));
            return null;
        }
 
        $this->sendPush(PushEventDictionary::EVENT_WORKGROUP_SUBSCRIBE_CHANGED, ['GROUP_ID' => $groupId]);
 
        return [
            'RESULT' => $result ? 'Y' : 'N',
        ];
    }
 
    public function updatePhotoAction(): bool
    {
        $groupId = $this->getRequest()->get('groupId');
 
        if (!Helper\Workgroup\Access::canUpdate([ 'groupId' => $groupId ]))
        {
            $this->addError(new Error('SOCIALNETWORK_GROUP_AJAX_NO_UPDATE_PERMS'));
            return false;
        }
 
        $workgroupData = WorkgroupTable::getList([
            'select' => [ 'ID', 'IMAGE_ID' ],
            'filter' => [
                '=ID' => $groupId,
            ],
        ])->fetch();
 
        $newPhotoFile = $this->getRequest()->getFile('newPhoto');
 
        if ($workgroupData['IMAGE_ID'])
        {
            $newPhotoFile['old_file'] = $workgroupData['IMAGE_ID'];
            $newPhotoFile['del'] = $workgroupData['IMAGE_ID'];
        }
 
        $res = \CSocNetGroup::update(
            $groupId,
            [ 'IMAGE_ID' => $newPhotoFile ],
            true,
            true,
            false
        );
 
        if (!$res)
        {
            $this->addError(new Error('SOCIALNETWORK_GROUP_AJAX_FAILED'));
            return false;
        }
 
        $this->sendPush(PushEventDictionary::EVENT_WORKGROUP_UPDATE, [
            'params' => [
                'GROUP_ID' => $groupId,
            ],
        ]);
 
        return true;
    }
 
    public function createGroupAction(): array
    {
        $groupName = $this->getRequest()->get('groupName');
        $viewMode = $this->getRequest()->get('viewMode');
        $groupImage = $this->getRequest()->getFile('groupImage');
        $avatarColor = $this->getRequest()->get('avatarColor');
 
        if (!Helper\Workgroup\Access::canCreate())
        {
            return ['groupId' => 0];
        }
 
        $ownerId = $this->getCurrentUser()->getId();
 
        $groupParams = [
            'SITE_ID' => [SITE_ID],
            'NAME' => $groupName,
            'SUBJECT_ID' => $this->getDefaultSubjectId(),
            'INITIATE_PERMS' => SONET_ROLES_USER,
            'SPAM_PERMS' => SONET_ROLES_USER,
            'VISIBLE' => $viewMode !== 'secret' ? 'Y' : 'N',
            'OPENED' => $viewMode === 'open' ? 'Y' : 'N',
        ];
 
        if (is_array($groupImage))
        {
            try
            {
                $avatarManager = new AvatarManager();
                $result = $avatarManager->loadAvatar($groupImage);
                $groupParams['IMAGE_ID'] = $avatarManager->getAvatar($result['fileId']);
            }
            catch (\RuntimeException)
            {
                unset($groupParams['IMAGE_ID']);
            }
        }
 
        if (!isset($groupParams['IMAGE_ID']))
        {
            $groupParams['AVATAR_TYPE'] = $this->getColoredDefaultAvatar($avatarColor);
        }
 
        $groupId = (int)\CSocNetGroup::createGroup($ownerId, $groupParams);
 
        global $APPLICATION;
        if ($e = $APPLICATION->GetException())
        {
            $this->addError(new Error($e->msg, $e->id));
            return [];
        }
 
        $this->setDefaultGroupFeatures($groupId);
 
        return [
            'groupId' => $groupId,
        ];
    }

    public function turnOnTrialAction(bool $scrum = false): bool
    {
        if (!Helper\Workgroup\Access::canCreate())
        {
            $this->addError(new Error('Access denied'));
 
            return false;
        }
 
        $feature = $scrum ? Helper\Feature::SCRUM_CREATE : Helper\Feature::PROJECTS_GROUPS;
 
        if (
            !Helper\Feature::isFeatureEnabled($feature)
            && Helper\Feature::canTurnOnTrial($feature)
        )
        {
            Helper\Feature::turnOnTrial($feature);
 
            return true;
        }
        else
        {
            $this->addError(new Error('Already included'));
 
            return false;
        }
    }
 
    private function getColoredDefaultAvatar(string $color): string
    {
        if (in_array($color, Helper\Workgroup::getAvatarColors(), true))
        {
            return "space_$color";
        }
 
        return array_rand(Helper\Workgroup::getColoredAvatarTypes());
    }
 
    private function setDefaultGroupFeatures(int $groupId): void
    {
        $allowedFeatures = array_keys(\CSocNetAllowed::getAllowedFeatures());
        $inactiveFeaturesList = ['forum', 'photo', 'search', 'group_lists', 'wiki'];
 
        $features = [];
        foreach ($allowedFeatures as $featureName)
        {
            $features[$featureName] = !in_array($featureName, $inactiveFeaturesList, true);
        }
 
        foreach ($features as $featureName => $isActive)
        {
            \CSocNetFeatures::setFeature(
                SONET_ENTITY_GROUP,
                $groupId,
                $featureName,
                $isActive,
            );
        }
    }
 
    private function getDefaultSubjectId(): int
    {
        $subject = \CSocNetGroupSubject::GetList(
            ["SORT"=>"ASC", "NAME" => "ASC"],
            ["SITE_ID" => SITE_ID],
            false,
            false,
            ["ID", "NAME"],
        )->fetch();
 
        return (int)($subject['ID'] ?? 0);
    }
 
    public function getCanCreateAction(): bool
    {
        return Helper\Workgroup\Access::canCreate([
            'checkAdminSession' => ($this->getScope() !== Controller::SCOPE_REST),
        ]);
    }
 
    public function updateInvitedUsersAction(int $spaceId, array $users): void
    {
        $membersManager = new MembersManager();
 
        if (!$membersManager->canInviteUsers($spaceId))
        {
            return;
        }
 
        $membersManager->updateInvitedUsers($spaceId, array_map(static fn($userId) => (int)$userId, $users));
    }
 
    public function getGridPopupMembersAction(
        int $groupId,
        string $type,
        int $page,
        string $componentName = '',
        string $signedParameters = ''
    ): ?array
    {
        if ($groupId <= 0)
        {
            $this->addEmptyGroupIdError();
 
            return null;
        }
 
        if (
            !Helper\Workgroup\Access::canView([
                'groupId' => $groupId,
                'checkAdminSession' => ($this->getScope() !== Controller::SCOPE_REST),
            ])
        )
        {
            $this->addError(new Error('Access denied'));
 
            return null;
        }
 
        $unsignedParameters = [];
        if (
            $componentName !== ''
            && $signedParameters !== ''
        )
        {
            $unsignedParameters = \Bitrix\Main\Component\ParameterSigner::unsignParameters(
                $componentName,
                $signedParameters
            );
            if (!is_array($unsignedParameters))
            {
                $unsignedParameters = [];
            }
        }
 
        $rolesMap = [
            'all' => [
                UserToGroupTable::ROLE_OWNER,
                UserToGroupTable::ROLE_MODERATOR,
                UserToGroupTable::ROLE_USER,
            ],
            'heads' => [
                UserToGroupTable::ROLE_OWNER,
                UserToGroupTable::ROLE_MODERATOR,
            ],
            'members' => [
                UserToGroupTable::ROLE_USER,
            ],
            'scrumTeam' => [
                UserToGroupTable::ROLE_OWNER,
                UserToGroupTable::ROLE_MODERATOR,
            ],
        ];
        $limit = 10;
 
        $query = UserToGroupTable::query();
        $records = $query
            ->setSelect([
                'GROUP_ID',
                'GROUP',
                'USER_ID',
                'ROLE',
                'INITIATED_BY_TYPE',
                'AUTO_MEMBER',
                'NAME' => 'USER.NAME',
                'LAST_NAME' => 'USER.LAST_NAME',
                'SECOND_NAME' => 'USER.SECOND_NAME',
                'LOGIN' => 'USER.LOGIN',
                'PERSONAL_PHOTO' => 'USER.PERSONAL_PHOTO',
            ])
            ->where('GROUP_ID', $groupId)
            ->whereIn('ROLE', $rolesMap[$type])
            ->setLimit($limit)
            ->setOffset(($page - 1) * $limit)
            ->exec()->fetchCollection();
 
        $isScrumMembers = ($type === 'scrumTeam');
        if ($isScrumMembers)
        {
            $query->addSelect('GROUP.SCRUM_MASTER_ID', 'SCRUM_MASTER_ID');
        }
 
        $imageIds = [];
        $resultMembers = [];
 
        foreach ($records as $member)
        {
            $imageIds[$member->get('USER_ID')] = $member->get('USER')->get('PERSONAL_PHOTO');
            $resultMembers[] = $member;
        }
 
        $imageIds = array_filter(
            $imageIds,
            static function ($id) { return (int)$id > 0; }
        );
        $avatars = Helper\UI\Grid\Workgroup\Members::getUserAvatars($imageIds);
        $pathToUser = ($unsignedParameters['PATH_TO_USER'] ?? Helper\Path::get('user_profile'));
        $userNameTemplate = ($unsignedParameters['NAME_TEMPLATE'] ?? \CSite::getNameFormat());
        $isIntranetInstalled = ModuleManager::isModuleInstalled('intranet');
 
        $members = [];
 
        foreach ($resultMembers as $member)
        {
            $id = $member->get('USER_ID');
            $userNameFormatted = \CUser::formatName($userNameTemplate, [
                'NAME' => $member->get('USER')->get('NAME'),
                'LAST_NAME' => $member->get('USER')->get('LAST_NAME'),
                'SECOND_NAME' => $member->get('USER')->get('SECOND_NAME'),
                'LOGIN' => $member->get('USER')->get('LOGIN'),
            ], $isIntranetInstalled);
 
            $userUrl = \CComponentEngine::makePathFromTemplate($pathToUser, [
                'user_id' => $id,
                'id' => $id,
            ]);
 
            $members[] = [
                'ID' => $id,
                'PHOTO' => $avatars[$imageIds[$id] ?? null] ?? '',
                'HREF' => $userUrl,
                'FORMATTED_NAME' => $userNameFormatted,
                'ROLE' => ($isScrumMembers ? $this->getScrumRole($member) : $member->get('ROLE')),
            ];
 
            if ($isScrumMembers)
            {
                if (
                    $member->get('ROLE') === UserToGroupTable::ROLE_OWNER
                    && $member->get('USER_ID') === $member->get('GROUP')->get('SCRUM_MASTER_ID')
                )
                {
                    $members[] = [
                        'ID' => $id,
                        'PHOTO' => $avatars[$imageIds[$id] ?? null] ?? '',
                        'HREF' => $userUrl,
                        'FORMATTED_NAME' => $userNameFormatted,
                        'ROLE' => 'M',
                    ];
                }
            }
        }
 
        return $members;
    }
 
    private function getScrumRole(EO_UserToGroup $member): string
    {
        if (
            $member->get('USER_ID') === $member->get('GROUP')->get('SCRUM_MASTER_ID')
            && $member->get('ROLE') !== UserToGroupTable::ROLE_OWNER
        )
        {
            return 'M';
        }
 
        return $member->get('ROLE');
    }

    public function changePinAction(
        array $groupIdList,
        string $action,
        string $componentName = '',
        string $signedParameters = ''
    ): ?bool
    {
        $unsignedParameters = [];
        if (
            $componentName !== ''
            && $signedParameters !== ''
        )
        {
            $unsignedParameters = \Bitrix\Main\Component\ParameterSigner::unsignParameters($componentName, $signedParameters);
            if (!is_array($unsignedParameters))
            {
                $unsignedParameters = [];
            }
        }
 
        $mode = ($unsignedParameters['MODE'] ?? '');
 
        $counter = 0;
 
        foreach ($groupIdList as $groupId)
        {
            $groupId = (int)$groupId;
 
            if (
                $groupId <= 0
                || !Helper\Workgroup\Access::canView([
                    'groupId' => $groupId,
                ])
            )
            {
                continue;
            }
 
            $counter++;
 
            $pin = new Pin($this->userId, $groupId, $mode);
            $result = $pin->switch();
 
            if (!$result->isSuccess())
            {
                $this->addErrors($result->getErrors());
                return null;
            }
 
            $this->sendPush(PushEventDictionary::EVENT_WORKGROUP_PIN_CHANGED, [
                    'GROUP_ID' => $groupId,
                    'ACTION' => $action,
                ]
            );
        }
 
        if ($counter <= 0)
        {
            $this->addEmptyGroupIdError();
            return null;
        }
 
        return true;
    }
 
    public function acceptIncomingRequestAction(int $groupId, array $userIds): ?array
    {
        try
        {
            $result = [];
 
            foreach ($userIds as $userId)
            {
                $result[$userId] = Helper\Workgroup::acceptIncomingRequest([
                    'groupId' => $groupId,
                    'userId' => $userId,
                ]);
            }
 
            // re-calculte counters for the group moderators
            $moderators = UserToGroupTable::getGroupModerators($groupId);
            Service::addEvent(
                EventDictionary::EVENT_WORKGROUP_MEMBER_REQUEST_CONFIRM,
                [
                    'GROUP_ID' => $groupId,
                    'RECEPIENTS' => array_map(function ($row) { return $row['USER_ID']; }, $moderators),
                ]
            );
 
            return $result;
        }
        catch (Exception $e)
        {
            $this->addError(new Error($e->getMessage()));
 
            return null;
        }
    }
 
    public function rejectIncomingRequestAction(int $groupId, array $userIds): ?array
    {
        try
        {
            $result = [];
 
            foreach ($userIds as $userId)
            {
                $result[$userId] = Helper\Workgroup::rejectIncomingRequest([
                    'groupId' => $groupId,
                    'userId' => $userId,
                ]);
            }
 
            // re-calculte counters for the group moderators
            $moderators = UserToGroupTable::getGroupModerators($groupId);
            Service::addEvent(
                EventDictionary::EVENT_WORKGROUP_MEMBER_REQUEST_CONFIRM,
                [
                    'GROUP_ID' => $groupId,
                    'RECEPIENTS' => array_map(function ($row) { return $row['USER_ID']; }, $moderators),
                ]
            );
 
            return $result;
        }
        catch (Exception $e)
        {
            $this->addError(new Error($e->getMessage()));
 
            return null;
        }
    }
 
    public function getListIncomingUsersAction(int $groupId, int $pageNum): ?array
    {
        $permissions = Helper\Workgroup::getPermissions(
            ['groupId' => $groupId]
        );
        if (!$permissions['UserCanModifyGroup'] && !$permissions['UserCanInitiate'])
        {
            $this->addError(new Error('Access denied'));
 
            return null;
        }
 
        $limit = 10;
        $offset = ($pageNum - 1) * $limit;
 
        return $this->getListOfAwaitingMembers($groupId, $limit, $offset);
    }
 
    public function getChatIdAction(int $groupId): ?string
    {
        $chatId = '';
 
        if (!Loader::includeModule('im'))
        {
            return $chatId;
        }
 
        $chatData = \Bitrix\Socialnetwork\Integration\Im\Chat\Workgroup::getChatData(
            [
                'group_id' => $groupId,
                'skipAvailabilityCheck' => true,
            ]
        );
        if (!empty($chatData[$groupId]) && intval($chatData[$groupId]) > 0)
        {
            $chatId = $chatData[$groupId];
        }
        else
        {
            $chatId = \Bitrix\Socialnetwork\Integration\Im\Chat\Workgroup::createChat(
                [
                    'group_id' => $groupId,
                ]
            );
        }
 
        return $chatId;
    }
 
    public function setFeatureAction(int $groupId, array $feature): bool
    {
        if (
            !Helper\Workgroup\Access::canModify([
                'groupId' => $groupId,
                'checkAdminSession' => ($this->getScope() !== Controller::SCOPE_REST),
            ])
        )
        {
            $this->addEmptyGroupIdError();
 
            return false;
        }
 
        $allowedFeatures = array_keys(\CSocNetAllowed::getAllowedFeatures());
 
        $featureId = is_string($feature['featureName'] ?? null) ? $feature['featureName'] : '';
        $customName = is_string($feature['customName'] ?? null) ? $feature['customName'] : false;
        $featureActive = is_string($feature['active'] ?? null) && $feature['active'] === 'true';
 
        $activeFeatures = \CSocNetFeatures::GetActiveFeatures(SONET_ENTITY_GROUP, $groupId);
 
        if (in_array($featureId, $allowedFeatures, true))
        {
            \CSocNetFeatures::setFeature(
                SONET_ENTITY_GROUP,
                $groupId,
                $featureId,
                $featureActive,
                $customName,
            );
        }
 
        $action = '';
 
        if ($featureActive === in_array($featureId ,$activeFeatures))
        {
            $action = 'change';
        }
 
        if ($featureActive && !in_array($featureId ,$activeFeatures))
        {
            $action = 'add';
        }
 
        if (!$featureActive && in_array($featureId ,$activeFeatures))
        {
            $action = 'delete';
        }
 
        $this->sendPush(PushEventDictionary::EVENT_SPACE_FEATURE_CHANGE, [
                'GROUP_ID' => $groupId,
                'FEATURE' => $feature,
                'ACTION' => $action,
            ]
        );
 
        return true;
    }
 
    private function getUserAvatars(array $imageIds): array
    {
        $result = [];
        if (empty($imageIds))
        {
            return $result;
        }
 
        $result = array_fill_keys($imageIds, '');
 
        $res = \CFile::getList([], ['@ID' => implode(',', $imageIds)]);
        while ($file = $res->fetch())
        {
            $file['SRC'] = \CFile::getFileSRC($file);
            $fileInfo = \CFile::resizeImageGet(
                $file,
                [
                    'width' => 100,
                    'height' => 100,
                ],
                BX_RESIZE_IMAGE_EXACT,
                false,
                false,
                true,
            );
 
            $result[$file['ID']] = $fileInfo['src'];
        }
 
        return $result;
    }
 
    private function sendPush(string $command, array $parameters = []): void
    {
        $parameters['USER_ID'] = $this->userId;
        PushService::addEvent(
            [$this->userId],
            [
                'module_id' => 'socialnetwork',
                'command' => $command,
                'params' => $parameters,
            ]
        );
    }
 
    private function addEmptyGroupIdError(): void
    {
        $this->addError(
            new Error(
                Loc::getMessage('SONET_CONTROLLER_WORKGROUP_EMPTY'),
                'SONET_CONTROLLER_WORKGROUP_EMPTY'
            )
        );
    }
 
    private function addIncorrectValueError(): void
    {
        $this->addError(new Error(
            'SONET_CONTROLLER_WORKGROUP_INCORRECT_VALUE',
            'SONET_CONTROLLER_WORKGROUP_INCORRECT_VALUE'
        ));
    }
}