typedatamanager.php

<?php
 
namespace Bitrix\Main\UserField\Internal;
 
use Bitrix\Main\Application;
use Bitrix\Main\DB\MssqlConnection;
use Bitrix\Main\DB\SqlQueryException;
use Bitrix\Main\Entity\Validator\RegExp;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\ORM\Data\DataManager;
use Bitrix\Main\ORM\Entity;
use Bitrix\Main\ORM\EntityError;
use Bitrix\Main\ORM\Event;
use Bitrix\Main\ORM\EventResult;
use Bitrix\Main\ORM\Fields\ArrayField;
use Bitrix\Main\ORM\Fields\ExpressionField;
use Bitrix\Main\ORM\Fields\Field;
use Bitrix\Main\ORM\Fields\IntegerField;
use Bitrix\Main\ORM\Fields\Relations\Reference;
use Bitrix\Main\ORM\Fields\StringField;
use Bitrix\Main\ORM\Query\Query;
use Bitrix\Main\SystemException;
use Bitrix\Main\Text\StringHelper;
 
abstract class TypeDataManager extends DataManager
{
    public const MAXIMUM_TABLE_NAME_LENGTH = 64;
 
    protected static $temporaryStorage;
 
    public static function getMap(): array
    {
        return [
            (new IntegerField('ID'))
                ->configurePrimary()
                ->configureAutocomplete(),
            (new StringField('NAME'))
                ->configureRequired()
                ->configureUnique()
                ->configureSize(100)
                ->configureFormat('/^[A-Z][A-Za-z0-9]*$/')
                ->addValidator(new RegExp(
                    '/(?<!Table)$/i'
                )),
            (new StringField('TABLE_NAME'))
                ->configureRequired()
                ->configureUnique()
                ->configureSize(64)
                ->configureFormat('/^[a-z0-9_]+$/')
                ->addValidator([get_called_class(), 'validateTableExisting']),
        ];
    }
 
    public static function getFactory(): TypeFactory
    {
        return Registry::getInstance()->getFactoryByTypeDataClass(static::class);
    }
 
    protected static function getTemporaryStorage(): TemporaryStorage
    {
        if(!static::$temporaryStorage)
        {
            static::$temporaryStorage = new TemporaryStorage();
        }
 
        return static::$temporaryStorage;
    }
 
    public static function onAfterAdd(Event $event): EventResult
    {
        $id = $event->getParameter('id');
 
        static::compileEntity($id)->createDbTable();
 
        return new EventResult();
    }
 
    public static function onBeforeUpdate(Event $event): EventResult
    {
        $data = static::getByPrimary($event->getParameter('id'))->fetch();
        static::getTemporaryStorage()->saveData($event->getParameter('id'), $data);
 
        return new EventResult();
    }
 
    public static function onAfterUpdate(Event $event): EventResult
    {
        $id = $event->getParameter('id');
        $data = $event->getParameter('fields');
        $oldData = static::getTemporaryStorage()->getData($id);
        if(!$oldData)
        {
            return new EventResult();
        }
 
        // rename table in db
        if (isset($data['TABLE_NAME']) && $data['TABLE_NAME'] !== $oldData['TABLE_NAME'])
        {
            $userFieldManager = UserFieldHelper::getInstance()->getManager();
            $connection = Application::getConnection();
            $sqlHelper = $connection->getSqlHelper();
            $connection->renameTable($oldData['TABLE_NAME'], $data['TABLE_NAME']);
 
            if ($connection instanceof MssqlConnection)
            {
                // rename constraint
                $connection->query(sprintf(
                    "EXEC sp_rename %s, %s, 'OBJECT'",
                    $sqlHelper->quote($oldData['TABLE_NAME'].'_ibpk_1'),
                    $sqlHelper->quote($data['TABLE_NAME'].'_ibpk_1')
                ));
            }
 
            // rename also uf multiple tables and its constraints, sequences, and triggers
            foreach ($userFieldManager->getUserFields(static::getFactory()->getUserFieldEntityId($oldData['ID'])) as $field)
            {
                if ($field['MULTIPLE'] == 'Y')
                {
                    $oldUtmTableName = static::getMultipleValueTableName($oldData, $field);
                    $newUtmTableName = static::getMultipleValueTableName($data, $field);
 
                    $connection->renameTable($oldUtmTableName, $newUtmTableName);
                }
            }
        }
 
        return new EventResult();
    }
 
    public static function onBeforeDelete(Event $event): EventResult
    {
        $result = new EventResult();
 
        $id = $event->getParameter('id');
        $oldData = static::getByPrimary($id)->fetch();
        static::getTemporaryStorage()->saveData($id, $oldData);
        if(!$oldData)
        {
            return $result;
        }
 
        $userFieldManager = UserFieldHelper::getInstance()->getManager();
 
        // get file fields
        $file_fields = [];
        $fields = $userFieldManager->getUserFields(static::getFactory()->getUserFieldEntityId($oldData['ID']));
 
        foreach ($fields as $name => $field)
        {
            if ($field['USER_TYPE']['BASE_TYPE'] === 'file')
            {
                $file_fields[] = $name;
            }
        }
 
        // delete files
        if (!empty($file_fields))
        {
            $oldEntity = static::compileEntity($oldData);
 
            $query = new Query($oldEntity);
 
            // select file ids
            $query->setSelect($file_fields);
 
            // if they are not empty
            $filter = array('LOGIC' => 'OR');
 
            foreach ($file_fields as $file_field)
            {
                $filter['!'.$file_field] = false;
            }
 
            $query->setFilter($filter);
 
            // go
            $queryResult = $query->exec();
 
            while ($row = $queryResult->fetch())
            {
                foreach ($file_fields as $file_field)
                {
                    if (!empty($row[$file_field]))
                    {
                        if (is_array($row[$file_field]))
                        {
                            foreach ($row[$file_field] as $value)
                            {
                                \CFile::delete($value);
                            }
                        }
                        else
                        {
                            \CFile::delete($row[$file_field]);
                        }
                    }
                }
            }
        }
 
        $connection = Application::getConnection();
 
        foreach ($fields as $field)
        {
            // delete from uf registry
            if ($field['USER_TYPE']['BASE_TYPE'] === 'enum')
            {
                $enumField = new \CUserFieldEnum;
                $enumField->DeleteFieldEnum($field['ID']);
            }
 
            $connection->query("DELETE FROM b_user_field_lang WHERE USER_FIELD_ID = ".$field['ID']);
            $connection->query("DELETE FROM b_user_field WHERE ID = ".$field['ID']);
 
            // if multiple - drop utm table
            if ($field['MULTIPLE'] == 'Y')
            {
                try
                {
                    $utmTableName = static::getMultipleValueTableName($oldData, $field);
                    $connection->dropTable($utmTableName);
                }
                catch(SqlQueryException $e)
                {
                    $result->addError(new EntityError($e->getMessage()));
                }
            }
        }
 
        // clear uf cache
        $managedCache = Application::getInstance()->getManagedCache();
        if(CACHED_b_user_field !== false)
        {
            $managedCache->cleanDir("b_user_field");
        }
 
        return $result;
    }
 
    public static function onAfterDelete(Event $event): EventResult
    {
        $id = $event->getParameter('id');
        $oldData = static::getTemporaryStorage()->getData($id);
        if(!$oldData)
        {
            return new EventResult();
        }
 
        if(Application::getConnection()->isTableExists($oldData['TABLE_NAME']))
        {
            Application::getConnection()->dropTable($oldData['TABLE_NAME']);
        }
 
        return new EventResult();
    }
 
    public static function resolveType($type): ?array
    {
        if($type instanceof Type)
        {
            $type = $type->collectValues();
        }
        if (!is_array($type))
        {
            if (is_int($type) || is_numeric(mb_substr($type, 0, 1)))
            {
                // we have an id
                $type = static::getById($type)->fetch();
            }
            elseif (is_string($type) && $type !== '')
            {
                // we have a name
                $type = static::query()->addSelect('*')->where('NAME', $type)->exec()->fetch();
            }
            else
            {
                $type = null;
            }
        }
        if (empty($type))
            return null;
 
        if (!isset($type['ID']))
            return null;
        if (!isset($type['NAME']) || !preg_match('/^[a-z0-9_]+$/i', $type['NAME']))
            return null;
        if (empty($type['TABLE_NAME']))
            return null;
 
        return $type;
    }
 
    public static function compileEntity($type): Entity
    {
        $rawType = $type;
        $type = static::resolveType($type);
        if (empty($type))
        {
            throw new SystemException(sprintf(
                'Invalid type description `%s`.', mydump($rawType)
            ));
        }
        $factory = static::getFactory();
        $type['code'] = $factory->getCode();
        $itemDataClass = $factory->getItemPrototypeDataClass();
        $userFieldManager = UserFieldHelper::getInstance()->getManager();
 
        $userFields = $userFieldManager->getUserFields($factory->getUserFieldEntityId($type['ID']));
 
        $entityName = $type['code'] . '_items_' . $type['ID'];
        $entityClassName = $entityName.'Table';
        $entityTableName = $type['TABLE_NAME'];
        if(class_exists($entityClassName))
        {
            // rebuild if it already exists
            Entity::destroy($entityClassName);
            $entity = Entity::getInstance($entityClassName);
        }
        else
        {
            $entity = Entity::compileEntity($entityName, [], [
                'table_name' => $entityTableName,
                'parent' => $itemDataClass,
                'object_parent' => $factory->getItemParentClass(),
                //'namespace' => __NAMESPACE__,
            ]);
        }
        Registry::getInstance()->registerTypeByEntity($entity, $type);
 
        foreach ($userFields as $userField)
        {
            if ($userField['MULTIPLE'] == 'N')
            {
                // just add single field
                $params = [
                    'required' => ($userField['MANDATORY'] === 'Y')
                ];
                $field = $userFieldManager->getEntityField($userField, $userField['FIELD_NAME'], $params);
                $entity->addField($field);
                foreach ($userFieldManager->getEntityReferences($userField, $field) as $reference)
                {
                    $entity->addField($reference);
                }
            }
            else
            {
                // build utm entity
                static::compileUtmEntity($entity, $userField);
            }
        }
 
        return $entity;
    }
 
    protected static function compileUtmEntity(Entity $typeEntity, $userField): Entity
    {
        $userFieldManager = UserFieldHelper::getInstance()->getManager();
 
        // build utm entity
        $itemDataClass = $typeEntity->getDataClass();
        $typeData = $itemDataClass::getType();
 
        $utmClassName = static::getUtmEntityClassName($typeEntity, $userField);
        $utmTableName = static::getMultipleValueTableName($typeData, $userField);
 
        if (class_exists($utmClassName.'Table'))
        {
            // rebuild if it already exists
            Entity::destroy($utmClassName.'Table');
            $utmEntity = Entity::getInstance($utmClassName);
        }
        else
        {
            // create entity from scratch
            $utmEntity = Entity::compileEntity($utmClassName, [], [
                'table_name' => $utmTableName,
                //'namespace' => __NAMESPACE__,
            ]);
        }
 
        // main fields
        $utmValueField = $userFieldManager->getEntityField($userField, 'VALUE');
 
        $utmEntityFields = array(
            new IntegerField('ID'),
            $utmValueField
        );
 
        // references
        $references = $userFieldManager->getEntityReferences($userField, $utmValueField);
 
        foreach ($references as $reference)
        {
            $utmEntityFields[] = $reference;
        }
 
        foreach ($utmEntityFields as $field)
        {
            $utmEntity->addField($field);
        }
 
        // add original entity reference
        $referenceField = new Reference(
            'OBJECT',
            $typeEntity,
            ['=this.ID' => 'ref.ID']
        );
 
        $utmEntity->addField($referenceField);
 
        // add short alias for back-reference
        $aliasField = new ExpressionField(
            $userField['FIELD_NAME'].'_SINGLE',
            '%s',
            $utmEntity->getFullName().':'.'OBJECT.VALUE',
            array(
                'data_type' => get_class($utmEntity->getField('VALUE')),
                'required' => $userField['MANDATORY'] == 'Y'
            )
        );
 
        $typeEntity->addField($aliasField);
 
        $cacheField = new ArrayField($userField['FIELD_NAME']);
        $cacheField->configureRequired($userField['MANDATORY'] === 'Y');
        $cacheField->configureSerializationPhp();
 
        $typeEntity->addField($cacheField);
 
        return $utmEntity;
    }
 
    public static function getUtmEntityClassName(Entity $typeEntity, array $userField): string
    {
        return $typeEntity->getName() . 'Utm' . StringHelper::snake2camel($userField['FIELD_NAME']);
    }
 
    public static function getMultipleValueTableName(array $type, array $userField): string
    {
        $tableName = $type['TABLE_NAME'] . '_' . mb_strtolower($userField['FIELD_NAME']);
 
        if (mb_strlen($tableName) > static::MAXIMUM_TABLE_NAME_LENGTH && !empty($userField['ID']))
        {
            $tableName = $type['TABLE_NAME'] . '_' . $userField['ID'];
        }
 
        return $tableName;
    }
 
    public static function validateTableExisting($value, $primary, array $row, Field $field)
    {
        $checkName = null;
 
        if (empty($primary))
        {
            // new row
            $checkName = $value;
        }
        else
        {
            $factory = static::getFactory();
            $typeDataClass = $factory->getTypeDataClass();
            // update row
            $oldData = $typeDataClass::getByPrimary($primary)->fetch();
 
            if ($value != $oldData['TABLE_NAME'])
            {
                // table name has been changed for existing row
                $checkName = $value;
            }
        }
 
        if (!empty($checkName))
        {
            if (Application::getConnection()->isTableExists($checkName))
            {
                Loc::loadLanguageFile(__DIR__.'/highloadblock.php');
                return Loc::getMessage('HIGHLOADBLOCK_HIGHLOAD_BLOCK_ENTITY_TABLE_NAME_ALREADY_EXISTS',
                    ['#TABLE_NAME#' => $value]
                );
            }
        }
 
        return true;
    }
 
    public static function getObjectParentClass(): string
    {
        return Type::class;
    }
}