user.php

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

<?php
namespace Bitrix\Bizproc\Service;
 
use Bitrix\Bizproc\FieldType;
use Bitrix\Main;
use Bitrix\Main\Localization\Loc;
use Bitrix\HumanResources\Service\Container;
use Bitrix\HumanResources\Item\NodeMember;
use Bitrix\HumanResources\Compatibility\Utils\DepartmentBackwardAccessCode;
use Bitrix\Main\UserGroupTable;
 
class User extends \CBPRuntimeService
{
    protected const DEPARTMENT_MODULE_ID = 'intranet';
    protected const DEPARTMENT_OPTION_NAME = 'iblock_structure';
 
    protected array $users = [];
 
    public function getUserDepartments(int $userId): array
    {
        // it's OK for now to use old api
        return $this->getUserDepartmentsOld($userId);
    }
 
    public function getUserInfo(int $userId): ?array
    {
        if ($userId <= 0)
        {
            return null;
        }
 
        if (isset($this->users[$userId]))
        {
            return $this->users[$userId];
        }
 
        $userFields = $this->getUserUserFields();
 
        return $this->loadUser($userId, $userFields);
    }
 
    public function getUserExtendedFields(): array
    {
        $fields = $this->getUserUserFields();
 
        if ($this->canUseIntranet())
        {
            $fields['UF_DEPARTMENT'] = [
                'Name' => Loc::getMessage('BP_SERVICE_USER_DEPARTMENT_1'),
                'Type' => 'int',
                'Multiple' => true,
            ];
 
            $fields['UF_DEPARTMENT_PRINTABLE'] = [
                'Name' => Loc::getMessage('BP_SERVICE_USER_DEPARTMENT_PRINTABLE_1'),
                'Type' => 'string',
                'Multiple' => true,
            ];
 
            $fields['IS_ABSENT'] = [
                'Name' => Loc::getMessage('BP_SERVICE_USER_IS_ABSENT'),
                'Type' => 'bool',
            ];
 
            if ($this->canUseIblockApi() || $this->canUseHumanResources())
            {
                $fields['UF_HEAD'] = [
                    'Name' => Loc::getMessage('BP_SERVICE_USER_HEAD'),
                    'Type' => 'user',
                    'Multiple' => true,
                ];
            }
        }
 
        if ($this->canUseTimeman())
        {
            $fields['TIMEMAN_STATUS'] = [
                'Name' => Loc::getMessage('BP_SERVICE_USER_TIMEMAN_STATUS'),
                'Type' => 'select',
                'Options' => [
                    'EXPIRED' => Loc::getMessage('BP_SERVICE_USER_TIMEMAN_STATUS_EXPIRED'),
                    'OPENED' => Loc::getMessage('BP_SERVICE_USER_TIMEMAN_STATUS_OPENED'),
                    'PAUSED' => Loc::getMessage('BP_SERVICE_USER_TIMEMAN_STATUS_PAUSED'),
                    'CLOSED' => Loc::getMessage('BP_SERVICE_USER_TIMEMAN_STATUS_CLOSED'),
                ],
            ];
        }
 
        if ($this->canUseHumanResources())
        {
            $fields['HR_NODE_IDS'] = [
                'Name' => Loc::getMessage('BP_SERVICE_USER_HR_NODE_IDS'),
                'Type' => 'int',
                'Multiple' => true,
            ];
            $fields['HR_NODE'] = [
                'Name' => Loc::getMessage('BP_SERVICE_USER_HR_NODE'),
                'Type' => 'user',
                'Multiple' => true,
            ];
        }
 
        return $fields;
    }
 
    public function getUserBaseFields(): array
    {
        return [
            'ACTIVE' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_ACTIVE'),
                'Type' => 'bool',
            ],
            'EMAIL' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_EMAIL'),
                'Type' => 'string',
            ],
            'WORK_PHONE' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_WORK_PHONE'),
                'Type' => 'string',
            ],
            'PERSONAL_MOBILE' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_PERSONAL_MOBILE'),
                'Type' => 'string',
            ],
            'UF_PHONE_INNER' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_UF_PHONE_INNER'),
                'Type' => 'string',
            ],
            'LOGIN' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_LOGIN'),
                'Type' => 'string',
            ],
            'NAME' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_NAME'),
                'Type' => 'string',
            ],
            'LAST_NAME' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_LAST_NAME'),
                'Type' => 'string',
            ],
            'SECOND_NAME' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_SECOND_NAME'),
                'Type' => 'string',
            ],
            'WORK_POSITION' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_WORK_POSITION'),
                'Type' => 'string',
            ],
            'PERSONAL_BIRTHDAY' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_PERSONAL_BIRTHDAY'),
                'Type' => 'date',
            ],
            'PERSONAL_WWW' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_PERSONAL_WWW'),
                'Type' => 'string',
            ],
            'PERSONAL_CITY' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_PERSONAL_CITY'),
                'Type' => 'string',
            ],
            'UF_DEPARTMENT' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_DEPARTMENT_1'),
                'Type' => 'int',
                'Multiple' => true,
            ],
            'UF_SKYPE' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_UF_SKYPE'),
                'Type' => 'string',
            ],
            'UF_TWITTER' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_UF_TWITTER'),
                'Type' => 'string',
            ],
            'UF_FACEBOOK' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_UF_FACEBOOK'),
                'Type' => 'string',
            ],
            'UF_LINKEDIN' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_UF_LINKEDIN'),
                'Type' => 'string',
            ],
            'UF_XING' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_UF_XING'),
                'Type' => 'string',
            ],
            'UF_WEB_SITES' => [
                'Name' => Loc::getMessage('BP_SERVICE_USER_UF_WEB_SITES'),
                'Type' => 'string',
            ],
        ];
    }
 
    public function getUserDepartmentChains(int $userId): array
    {
        $chains = [];
 
        foreach ($this->getUserDepartments($userId) as $departmentId)
        {
            $chains[] = $this->getDepartmentChain($departmentId);
        }
 
        return $chains;
    }
 
    public function getDepartmentChain(int $departmentId): array
    {
        if (!$this->canUseHumanResources())
        {
            return $this->getDepartmentChainOld($departmentId);
        }
 
        $chain = [];
        $node = $this->getDepartmentNode($departmentId);
 
        if ($node)
        {
            $nodes = Container::getNodeRepository()->getParentOf(
                $node,
                \Bitrix\HumanResources\Enum\DepthLevel::FULL,
            );
            foreach ($nodes as $parent)
            {
                $idByAccessCode = DepartmentBackwardAccessCode::extractIdFromCode($parent->accessCode);
                if ($idByAccessCode !== null)
                {
                    $chain[] = $idByAccessCode;
                }
            }
        }
 
        return $chain;
    }
 
    public function getUserHeads(int $userId): array
    {
        $heads = [];
        $userDepartments = $this->getUserDepartmentChains($userId);
 
        foreach ($userDepartments as $chain)
        {
            foreach ($chain as $deptId)
            {
                $departmentHead = $this->getDepartmentHead($deptId);
 
                if (!$departmentHead || $departmentHead === $userId)
                {
                    continue;
                }
 
                $heads[] = $departmentHead;
                break;
            }
        }
 
        return array_unique($heads);
    }
 
    public function getDepartmentHead(int $departmentId): ?int
    {
        if (!$this->canUseHumanResources())
        {
            return $this->getDepartmentHeadOld($departmentId);
        }
 
        $node = $this->getDepartmentNode($departmentId);
        if (!$node)
        {
            return null;
        }
 
        $head = current(Container::getNodeMemberService()->getDefaultHeadRoleEmployees($node->id)->getItemMap());
 
        return $head->entityId ?? null;
    }
 
    public function getUserSchedule(int $userId): Sub\UserSchedule
    {
        return new Sub\UserSchedule($userId);
    }
 
    protected function getDepartmentIblockId(): int
    {
        return (int) Main\Config\Option::get(
            static::DEPARTMENT_MODULE_ID,
            static::DEPARTMENT_OPTION_NAME
        );
    }
 
    private function canUseHumanResources(): bool
    {
        return Main\Loader::includeModule('humanresources');
    }
 
    private function canUseIblockApi()
    {
        return Main\Loader::includeModule('iblock');
    }
 
    private function canUseIntranet()
    {
        return Main\Loader::includeModule('intranet');
    }
 
    private function canUseTimeman()
    {
        return \CBPHelper::isWorkTimeAvailable();
    }
 
    public function getUserUserFields(): array
    {
        static $fields;
 
        if (isset($fields))
        {
            return $fields;
        }
 
        $fields = [];
 
        $userFields = Main\UserFieldTable::getList([
            'select' => array_merge(
                ['ID', 'FIELD_NAME', 'USER_TYPE_ID', 'MULTIPLE'],
                Main\UserFieldTable::getLabelsSelect()
            ),
            'filter' => [
                '=ENTITY_ID' => 'USER',
                '%=FIELD_NAME' => 'UF_USR_%',
            ],
            'runtime' => [
                Main\UserFieldTable::getLabelsReference('LABELS', \LANGUAGE_ID),
            ],
        ])->fetchAll();
 
 
        foreach ($userFields as $field)
        {
            $fieldName = $field['FIELD_NAME'];
            $fieldType = FieldType::convertUfType($field['USER_TYPE_ID']) ?? "UF:{$field['USER_TYPE_ID']}";
 
            $name = empty($field['LIST_COLUMN_LABEL']) ? $field['FIELD_NAME'] : $field['LIST_COLUMN_LABEL'];
 
            $fields[$fieldName] = [
                'Name' => $name,
                'Type' => $fieldType,
                'Multiple' => $field['MULTIPLE'] === 'Y',
            ];
 
            if ($fields[$fieldName]['Type'] === 'select')
            {
                $fieldData = Main\UserFieldTable::getFieldData($field['ID']);
                $fields[$fieldName]['Options'] = array_combine(
                    array_column($fieldData['ENUM'], 'XML_ID'),
                    array_column($fieldData['ENUM'], 'VALUE'),
                );
                $fields[$fieldName]['Settings'] = ['ENUM' => $fieldData['ENUM']];
            }
        }
 
        return $fields;
    }
 
    public function extractUsersFromDepartment(int $departmentId, bool $recursive = false): ?array
    {
        if (!$this->canUseHumanResources())
        {
            return $this->extractUsersFromDepartmentOld($departmentId, $recursive);
        }
 
        $node = $this->getDepartmentNode($departmentId);
        if (!$node)
        {
            return null;
        }
 
        return $this->extractUsersFromHrNode($node->id, $recursive);
    }
 
    public function extractUsersFromGroup(int $groupId): array
    {
        if ($groupId <= 0)
        {
            return [];
        }
 
        $userIds =
            array_column(
                UserGroupTable::query()
                    ->setSelect(['USER_ID'])
                    ->where('GROUP_ID', $groupId)
                    ->setOrder(['USER_ID' => 'ASC'])
                    ->exec()
                    ->fetchAll(),
                'USER_ID'
            )
        ;
 
        Main\Type\Collection::normalizeArrayValuesByInt($userIds, false);
 
        return $userIds;
    }
 
    public function extractUsersFromAllDepartments(): bool | array
    {
        if (!$this->canUseHumanResources())
        {
            return $this->extractUsersFromAllDepartmentsOld();
        }
 
        $rootNode = \Bitrix\HumanResources\Util\StructureHelper::getRootStructureDepartment();
        if ($rootNode)
        {
            $employees = Container::getNodeMemberService()->getAllEmployees($rootNode->id, true);
 
            $result = array_map(static fn(NodeMember $item) => $item->entityId, [...$employees->getItemMap()]);
            Main\Type\Collection::normalizeArrayValuesByInt($result);
 
            return $result;
        }
 
        return false;
    }

    private function extractUsersFromAllDepartmentsOld(): bool | array
    {
        if (Main\Loader::includeModule('intranet'))
        {
            $result = [];
            $iterator = \CUser::GetList(
                'ID',
                'ASC',
                ['ACTIVE' => 'Y', '>UF_DEPARTMENT' => 0],
                ['FIELDS' => ['ID']]
            );
            while ($user = $iterator->Fetch())
            {
                $result[] = (int)$user['ID'];
            }
 
            return $result;
        }
 
        return false;
    }
 
    public function extractUsersFromSocNetGroup(int $groupId, string $role = 'K'): bool | array
    {
        if (Main\Loader::includeModule('socialnetwork'))
        {
            $result = [];
            $iterator = \CSocNetUserToGroup::GetList(
                ['USER_ID' => 'ASC'],
                ['=GROUP_ID' => $groupId, '<=ROLE' => $role, 'USER_ACTIVE' => 'Y'],
                false,
                false,
                ['USER_ID']
            );
            while ($user = $iterator->Fetch())
            {
                $result[] = (int)$user['USER_ID'];
            }
 
            return $result;
        }
 
        return false;
    }
 
    public function extractUsersFromHrNode(int $nodeId, bool $recursive = true): ?array
    {
        if ($nodeId <= 0 || !$this->canUseHumanResources())
        {
            return null;
        }
 
        $employeesCollection = Container::getNodeMemberService()->getPagedEmployees($nodeId, $recursive);
 
        return array_values(
            array_unique(
                array_map(static fn(NodeMember $item) => $item->entityId, [...$employeesCollection->getItemMap()])
            )
        );
    }
 
    private function convertValues(array &$values, array $userFields): void
    {
        foreach ($userFields as $id => $field)
        {
            if ($field['Type'] === 'bool')
            {
                $values[$id] = \CBPHelper::getBool($values[$id]) ? 'Y' : 'N';
            }
            elseif ($field['Type'] === 'select')
            {
                $values[$id] = $this->convertSelectValue($values[$id], $field);
            }
        }
 
        if (!empty($values['UF_DEPARTMENT']))
        {
            $values['UF_DEPARTMENT_PRINTABLE'] = $this->loadDepartmentNames($values['UF_DEPARTMENT']);
        }
    }
 
    private function convertSelectValue($value, $field)
    {
        $enumIds = array_combine(
            array_column($field['Settings']['ENUM'], 'XML_ID'),
            array_column($field['Settings']['ENUM'], 'ID'),
        );
 
        if (is_array($value))
        {
            $xmlIds = [];
            foreach ($value as $val)
            {
                $xmlIds[] = array_search($val, $enumIds);
            }
 
            return array_filter($xmlIds, fn($id) => $id !== false);
        }
 
        $xmlId = array_search($value, $enumIds);
 
        return $xmlId !== false ? $xmlId : '';
    }
 
    private function convertUserValue($value): array
    {
        $users = [];
 
        $value = is_array($value) ? $value : [$value];
        foreach ($value as $userId)
        {
            if (is_int($userId))
            {
                $users[] = 'user_' . $userId;
            }
        }
 
        return $users;
    }
 
    private function loadUser(int $userId, array $fields): ?array
    {
        $dbUsers = \CUser::GetList(
            'id',
            'asc',
            ['ID_EQUAL_EXACT' => $userId],
            [
                'FIELDS' => [
                    'ID',
                    'EMAIL',
                    'WORK_PHONE',
                    'PERSONAL_MOBILE',
                    'PERSONAL_BIRTHDAY',
                    'LOGIN',
                    'ACTIVE',
                    'NAME',
                    'LAST_NAME',
                    'SECOND_NAME',
                    'WORK_POSITION',
                    'PERSONAL_WWW',
                    'PERSONAL_CITY',
                ],
                'SELECT' => [
                    'UF_DEPARTMENT',
                    'UF_SKYPE',
                    'UF_TWITTER',
                    'UF_FACEBOOK',
                    'UF_LINKEDIN',
                    'UF_XING',
                    'UF_WEB_SITES',
                    'UF_PHONE_INNER',
                    ...array_keys($fields),
                ],
            ]
        );
 
        $user = $dbUsers->fetch();
 
        if (is_array($user))
        {
            if ($this->canUseHumanResources())
            {
                $user['HR_NODE_IDS'] =
                    array_map(
                        static fn (\Bitrix\HumanResources\Item\Node $node) => $node->id,
                        [...Container::getNodeRepository()->findAllByUserId($userId)->getItemMap()]
                    )
                ;
                $user['HR_NODE'] = array_map(static fn(int $id) => 'group_hr' . $id, $user['HR_NODE_IDS']);
            }
 
            $this->convertValues($user, $fields);
            $this->users[$userId] = $user;
 
            $schedule = $this->getUserSchedule($userId);
            $this->users[$userId]['IS_ABSENT'] = $schedule->isAbsent();
            $this->users[$userId]['TIMEMAN_STATUS'] = $schedule->getWorkDayStatus();
            $this->users[$userId]['UF_HEAD'] = $this->convertUserValue($this->getUserHeads($userId));
 
            return $this->users[$userId];
        }
 
        return null;
    }
 
    private function loadDepartmentNames(array $ids): array
    {
        if (!$this->canUseHumanResources())
        {
            return $this->loadDepartmentNamesOld($ids);
        }
 
        $codes = array_map(
            static fn($id) => DepartmentBackwardAccessCode::makeById($id),
            $ids
        );
 
        $collection = Container::getNodeRepository()->findAllByAccessCodes($codes);
        $names = [];
        foreach ($collection as $node)
        {
            $names[DepartmentBackwardAccessCode::extractIdFromCode($node->accessCode)] = $node->name;
        }
 
        return array_values(array_filter(
            array_map(
                static fn($id) => $names[$id] ?? null,
                $ids
            )
        ));
    }
 
    private function getDepartmentNode(int $departmentId): ?\Bitrix\HumanResources\Item\Node
    {
        return Container::getNodeRepository()->getByAccessCode(DepartmentBackwardAccessCode::makeById($departmentId));
    }

    private function extractUsersFromDepartmentOld(int $departmentId, bool $recursive = false): ?array
    {
        if (!$this->canUseIntranet() || !$this->canUseIblockApi())
        {
            return null;
        }
 
        $iblockId = $this->getDepartmentIblockId();
        $departmentIds = [$departmentId];
 
        if ($recursive)
        {
            $iterator = \CIBlockSection::GetList(
                ['ID' => 'ASC'],
                ['=IBLOCK_ID' => $iblockId, 'ID' => $departmentId],
                false,
                ['ID', 'LEFT_MARGIN', 'RIGHT_MARGIN', 'DEPTH_LEVEL']
            );
            $section = $iterator->fetch();
            $filter = [
                '=IBLOCK_ID' => $iblockId,
                ">LEFT_MARGIN" => $section["LEFT_MARGIN"],
                "<RIGHT_MARGIN" => $section["RIGHT_MARGIN"],
                ">DEPTH_LEVEL" => $section['DEPTH_LEVEL'],
            ];
            $iterator = \CIBlockSection::GetList(["left_margin" => "asc"], $filter, false, ['ID']);
            while ($section = $iterator->fetch())
            {
                $departmentIds[] = $section['ID'];
            }
            unset($iterator, $section, $filter);
        }
        $result = [];
        $iterator = \CUser::GetList("departmentId", "asc",
            ['ACTIVE' => 'Y', 'UF_DEPARTMENT' => $departmentIds],
            ['FIELDS' => ['ID']]
        );
        while ($user = $iterator->fetch())
        {
            $result[] = (int)$user['ID'];
        }
 
        return $result;
    }

    private function loadDepartmentNamesOld(array $ids): array
    {
        $names = [];
 
        if (!Main\Loader::includeModule('intranet') || !Main\Loader::includeModule('iblock'))
        {
            return $names;
        }
 
        $iblockId = $this->getDepartmentIblockId();
 
        $iterator = \CIBlockSection::GetList(
            ['ID' => 'ASC'],
            [
                '=IBLOCK_ID' => $iblockId,
                'ID' => $ids,
                'CHECK_PERMISSIONS' => 'N',
            ],
            false,
            ['ID', 'NAME']
        );
 
        while ($row = $iterator->fetch())
        {
            $names[$row['ID']] = $row['NAME'];
        }
 
        return array_values(array_filter(
            array_map(
                fn($id) => $names[$id] ?? null,
                $ids
            )
        ));
    }

    private function getUserDepartmentsOld(int $userId): array
    {
        if (isset($this->users[$userId]['UF_DEPARTMENT']))
        {
            return is_array($this->users[$userId]['UF_DEPARTMENT']) ? $this->users[$userId]['UF_DEPARTMENT'] : [];
        }
 
        $departments = [];
        $result = \CUser::getList(
            'id', 'asc',
            ['ID_EQUAL_EXACT' => $userId],
            ['FIELDS' => ['ID'], 'SELECT' => ['UF_DEPARTMENT']]
        );
 
        if ($user = $result->fetch())
        {
            if (isset($user['UF_DEPARTMENT']))
            {
                $user['UF_DEPARTMENT'] = (array) $user['UF_DEPARTMENT'];
                foreach ($user['UF_DEPARTMENT'] as $dpt)
                {
                    $departments[] = (int) $dpt;
                }
            }
        }
 
        return $departments;
    }

    private function getDepartmentChainOld(int $departmentId): array
    {
        $chain = [];
 
        if (!$this->canUseIblockApi())
        {
            return $chain;
        }
 
        $departmentIblockId = $this->getDepartmentIblockId();
        $chain = \CIBlockSection::getNavChain($departmentIblockId, $departmentId, ['ID'], true);
 
        $chain = array_map(
            static fn($value) => (int)$value['ID'],
            $chain
        );
 
        return array_reverse($chain);
    }

    private function getDepartmentHeadOld(int $departmentId): ?int
    {
        if (!$this->canUseIblockApi())
        {
            return null;
        }
 
        $departmentIblockId = $this->getDepartmentIblockId();
        $sectionResult = \CIBlockSection::GetList(
            [],
            ['IBLOCK_ID' => $departmentIblockId, 'ID' => $departmentId],
            false,
            ['ID', 'UF_HEAD']
        );
        $section = $sectionResult->fetch();
 
        return $section ? (int) $section['UF_HEAD'] : null;
    }
}