userfieldconfig.php

<?php
 
namespace Bitrix\Main\Controller;
 
use Bitrix\Intranet\ActionFilter;
use Bitrix\Main\Engine\Action;
use Bitrix\Main\Engine\Controller;
use Bitrix\Main\Error;
use Bitrix\Main\Loader;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\ObjectNotFoundException;
use Bitrix\Main\UI\PageNavigation;
use Bitrix\Main\UserField\UserFieldAccess;
use Bitrix\Main\UserFieldTable;
use Bitrix\Main\Engine\Response\Converter;
use Bitrix\Main\Engine\Response\DataType\Page;
 
class UserFieldConfig extends Controller
{
    protected function getDefaultPreFilters()
    {
        $defaultPreFilters = parent::getDefaultPreFilters();
 
        if (Loader::includeModule('intranet'))
        {
            $defaultPreFilters[] = new ActionFilter\IntranetUser();
        }
 
        return $defaultPreFilters;
    }
 
    protected function getAccess(string $moduleId, ?\CRestServer $restServer = null): ?UserFieldAccess
    {
        try
        {
            $access = UserFieldAccess::getInstance($moduleId);
        }
        catch (ObjectNotFoundException $e)
        {
            if ($restServer)
            {
                $this->addError(new Error($e->getMessage()));
 
                return null;
            }
 
            throw $e;
        }
 
        if ($restServer)
        {
            $scopes = $restServer->getAuthScope();
            if (!in_array($moduleId, $scopes, true))
            {
                $this->addError(
                    new Error(
                        'The current method required more scopes. (' . $moduleId . ')',
                        \Bitrix\Rest\Engine\ActionFilter\Scope::ERROR_INSUFFICIENT_SCOPE
                    )
                );
 
                return null;
            }
        }
 
        return $access;
    }
 
    protected function processAfterAction(Action $action, $result)
    {
        $this->fillErrorsFromApplication();
 
        return null;
    }
 
    protected function getEmptyModuleIdError(): Error
    {
        return new Error(Loc::getMessage('MAIN_USER_FIELD_CONTROLLER_EMPTY_MODULE_ID_ERROR'));
    }
 
    protected function getReadAccessDeniedError(): Error
    {
        return new Error(Loc::getMessage('MAIN_USER_FIELD_CONTROLLER_ACCESS_VIEW_ERROR'));
    }
 
    protected function getAddAccessDeniedError(): Error
    {
        return new Error(loc::getMessage('MAIN_USER_FIELD_CONTROLLER_ACCESS_CREATE_ERROR'));
    }
 
    protected function getUpdateAccessDeniedError(): Error
    {
        return new Error(loc::getMessage('MAIN_USER_FIELD_CONTROLLER_ACCESS_MODIFY_ERROR'));
    }
 
    protected function getDeleteAccessDeniedError(): Error
    {
        return new Error(loc::getMessage('MAIN_USER_FIELD_CONTROLLER_ACCESS_DELETE_ERROR'));
    }
 
    protected function getCommonError(): Error
    {
        return new Error(Loc::getMessage('MAIN_USER_FIELD_CONTROLLER_ERROR'));
    }
 
    public function getTypesAction(string $moduleId, \CRestServer $restServer = null): ?array
    {
        $access = $this->getAccess($moduleId, $restServer);
        if (!$access)
        {
            return null;
        }
 
        $result = [];
 
        $restrictedTypes = array_flip($access->getRestrictedTypes());
 
        global $USER_FIELD_MANAGER;
        $types = $USER_FIELD_MANAGER->GetUserType();
 
        if (empty($restrictedTypes))
        {
            return $types;
        }
 
        foreach ($types as $id => $type)
        {
            if (!isset($restrictedTypes[$id]))
            {
                $result[$id] = [
                    'userTypeId' => $type['USER_TYPE_ID'],
                    'description' => $type['DESCRIPTION'],
                ];
            }
        }
 
        return [
            'types' => $result,
        ];
    }
 
    protected function prepareFields(array $fields): array
    {
        $allowedKeys = [
            'editFormLabel' => true,
            'multiple' => true,
            'userTypeId' => true,
            'fieldName' => true,
            'enum' => true,
            'entityId' => true,
            'xmlId' => true,
            'sort' => true,
            'mandatory' => true,
            'showFilter' => true,
            'isSearchable' => true,
            'settings' => true,
        ];
 
        $fields = array_intersect_key($fields, $allowedKeys);
 
        $converter = new Converter(Converter::TO_UPPER | Converter::KEYS | Converter::TO_SNAKE);
 
        if ($fields['showFilter'] === 'Y')
        {
            $fields['showFilter'] = 'E';
        }
 
        return $converter->process($fields);
    }
 
    public function preparePublicData(array $field): array
    {
        foreach (UserFieldTable::getLabelFields() as $labelName)
        {
            if (isset($field[$labelName]) && !is_array($field[$labelName]))
            {
                $field[$labelName] = [
                    Loc::getCurrentLang() => $field[$labelName],
                ];
            }
        }
        $settings = $field['SETTINGS'];
 
        $field = (
            new Converter(
                Converter::KEYS
                | Converter::TO_CAMEL
                | Converter::LC_FIRST
                | Converter::RECURSIVE
            )
        )->process($field);
 
        $field['settings'] = $settings;
 
        return $field;
    }
 
    protected function fillErrorsFromApplication(): void
    {
        global $APPLICATION;
 
        $exception = $APPLICATION->GetException();
        if (($exception instanceof \CAdminException) && is_array($exception->messages))
        {
            foreach ($exception->messages as $message)
            {
                if (isset($message['text']))
                {
                    $message = $message['text'];
                }
                $this->addError(new Error($message));
            }
        }
 
        $APPLICATION->ResetException();
    }
 
    protected function prepareEnums(array $newEnums, array $currentEnums): array
    {
        $deletedEnum = [];
        $storedEnum = [];
        $updatedEnum = [];
 
        foreach ($currentEnums as $enumItem)
        {
            $storedEnum[$enumItem['ID']] = $enumItem;
            $deletedEnum[$enumItem['ID']] = true;
        }
 
        $countAdded = 0;
        foreach ($newEnums as $enumItem)
        {
            if (is_array($enumItem))
            {
                if (!empty($enumItem['id']))
                {
                    if (empty($enumItem['xmlId']))
                    {
                        $enumItem['xmlId'] = $storedEnum[$enumItem['id']]['XML_ID'];
                    }
                    if (empty($enumItem['def']))
                    {
                        $enumItem['def'] = $storedEnum[$enumItem['id']]['DEF'];
                    }
 
                    unset($deletedEnum[$enumItem['id']]);
                }
                $itemKey = ($enumItem['id'] > 0 ? $enumItem['id'] : 'n' . ($countAdded++));
 
                $itemDescription = [
                    'VALUE' => $enumItem['value'],
                    'DEF' => $enumItem['def'] === 'Y' ? 'Y' : 'N',
                    'SORT' => $enumItem['sort'],
                ];
 
                if (!empty($enumItem['xmlId']))
                {
                    $itemDescription['XML_ID'] = $enumItem['xmlId'];
                }
 
                $enumItem['sort'] = (int)$enumItem['sort'];
                if ($enumItem['sort'] > 0)
                {
                    $itemDescription['SORT'] = $enumItem['sort'];
                }
 
                $updatedEnum[$itemKey] = $itemDescription;
            }
        }
 
        foreach ($deletedEnum as $deletedId => $t)
        {
            $updatedEnum[$deletedId] = [
                'ID' => $deletedId,
                'DEL' => 'Y',
            ];
        }
 
        return $updatedEnum;
    }
 
    protected function updateEnums(int $id, array $enums, array $currentEnums = []): void
    {
        $updatedEnum = $this->prepareEnums($enums, $currentEnums);
 
        $enumValuesManager = new \CUserFieldEnum();
        $setEnumResult = $enumValuesManager->setEnumValues($id, $updatedEnum);
 
        if (!$setEnumResult)
        {
            $this->fillErrorsFromApplication();
        }
    }
 
    public function getAction(string $moduleId, int $id, \CRestServer $restServer = null): ?array
    {
        $access = $this->getAccess($moduleId, $restServer);
        if (!$access)
        {
            return null;
        }
        if ($this->getErrors())
        {
            return null;
        }
        if (!$access->canRead($id))
        {
            $this->addError($this->getReadAccessDeniedError());
            return null;
        }
 
        $field = UserFieldTable::getFieldData($id);
        if (is_array($field))
        {
            return [
                'field' => $this->preparePublicData($field),
            ];
        }
 
        return null;
    }
 
    public function listAction(
        string $moduleId,
        array $select = ['*'],
        array $order = [],
        array $filter = [],
        PageNavigation $pageNavigation = null,
        \CRestServer $restServer = null
    ): ?Page
    {
        $access = $this->getAccess($moduleId, $restServer);
        if (!$access)
        {
            return null;
        }
 
        $converter = new Converter(Converter::TO_UPPER | Converter::KEYS | Converter::TO_SNAKE);
        $filter = $converter->process($filter);
        $order = $converter->process($order);
        $select = $converter->process($select);
 
        if (!$access->canReadWithFilter($filter))
        {
            $this->addError($this->getReadAccessDeniedError());
            return null;
        }
        $filter = $access->prepareFilter($filter);
 
        $runtime = [];
        if (!empty($select['LANGUAGE']) && is_string($select['LANGUAGE']))
        {
            $runtime[] = UserFieldTable::getLabelsReference('LABELS', $select['LANGUAGE']);
            unset($select['LANGUAGE']);
 
            $select = array_merge($select, UserFieldTable::getLabelsSelect());
        }
 
        $fields = [];
        $list = UserFieldTable::getList([
            'select' => $select,
            'filter' => $filter,
            'order' => $order,
            'offset' => $pageNavigation ? $pageNavigation->getOffset() : null,
            'limit' => $pageNavigation ? $pageNavigation->getLimit() : null,
            'runtime' => $runtime,
        ]);
        while ($field = $list->fetch())
        {
            $fields[] = $this->preparePublicData($field);
        }
 
        return new Page('fields', $fields, static function () use ($filter) {
            return UserFieldTable::getCount($filter);
        });
    }
 
    public function addAction(string $moduleId, array $field, \CRestServer $restServer = null): ?array
    {
        $access = $this->getAccess($moduleId, $restServer);
        if (!$access)
        {
            return null;
        }
        $field = $this->prepareFields($field);
        if (!$access->canAdd($field))
        {
            $this->addError($this->getAddAccessDeniedError());
            return null;
        }
 
        $fieldName = $field['FIELD_NAME'] ?? '';
        $entityId = $field['ENTITY_ID'] ?? '';
        $prefix = 'UF_' . $entityId . '_';
        if (strpos($fieldName, $prefix) !== 0)
        {
            $this->addError(new Error(Loc::getMessage('MAIN_USER_FIELD_CONTROLLER_FIELD_NAME_ERROR')));
            return null;
        }
 
        $userTypeEntity = new \CUserTypeEntity();
        $id = $userTypeEntity->Add($field);
        if ($id > 0)
        {
            if ($field['USER_TYPE_ID'] === 'enumeration')
            {
                $this->updateEnums($id, (array)$field['ENUM']);
            }
 
            return [
                'field' => $this->preparePublicData(UserFieldTable::getFieldData($id)),
            ];
        }
 
        $this->fillErrorsFromApplication();
        if (!$this->getErrors())
        {
            $this->addError($this->getCommonError());
        }
 
        return null;
    }
 
    public function updateAction(string $moduleId, int $id, array $field, \CRestServer $restServer = null): ?array
    {
        $access = $this->getAccess($moduleId, $restServer);
        if (!$access)
        {
            return null;
        }
        if (!$access->canUpdate($id))
        {
            $this->addError($this->getUpdateAccessDeniedError());
            return null;
        }
 
        $field = $this->prepareFields($field);
        $userTypeEntity = new \CUserTypeEntity();
        $isUpdated = $userTypeEntity->Update($id, $field);
        if ($isUpdated)
        {
            if ($field['USER_TYPE_ID'] === 'enumeration')
            {
                $this->updateEnums($id, (array)$field['ENUM'], (array)UserFieldTable::getFieldData($id)['ENUM']);
            }
 
            return [
                'field' => $this->preparePublicData(UserFieldTable::getFieldData($id)),
            ];
        }
 
        $this->fillErrorsFromApplication();
        if (!$this->getErrors())
        {
            $this->addError($this->getCommonError());
        }
 
        return null;
    }
 
    public function deleteAction(string $moduleId, int $id, \CRestServer $restServer = null): void
    {
        $access = $this->getAccess($moduleId, $restServer);
        if (!$access)
        {
            return;
        }
        if (!$access->canDelete($id))
        {
            $this->addError($this->getDeleteAccessDeniedError());
            return;
        }
 
        $userTypeEntity = new \CUserTypeEntity();
        $userTypeEntity->Delete($id);
    }
}