entity.php

<?php
namespace Bitrix\Catalog\Model;
 
use Bitrix\Main;
use Bitrix\Main\ORM;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\ORM\Data\DataManager;
 
Loc::loadMessages(__FILE__);
 
abstract class Entity
{
    const PREFIX_OLD = 'OLD_';
 
    public const EVENT_ON_BUILD_CACHED_FIELD_LIST = 'OnBuildCachedFieldList';
 
    public const FIELDS_MAIN = 0x0001;
    public const FIELDS_UF = 0x0002;
    public const FIELDS_ALL = self::FIELDS_MAIN|self::FIELDS_UF;
 
    private static $entity = [];
 
    private $tablet = null;
    private $tabletFields = [];
    private $tabletUserFields = [];
    private $result;
    private $cache = [];
    private $cacheModifyed = [];
 
    private $fields = [];
    private $fieldsCount = 0;
    private $aliases = [];
    private $fieldMask = [];
    private $fetchCutMask;
 
    public function __construct()
    {
        $this->initEntityTablet();
        $this->initEntityCache();
 
        $this->result = null;
        $this->fetchCutMask = [];
    }
 
    public static function getEntity(): Entity
    {
        $className = get_called_class();
        if (empty(self::$entity[$className]))
        {
            $entity = new static;
            self::$entity[$className] = $entity;
        }
 
        return self::$entity[$className];
    }
 
    public static function getList(array $parameters): Entity
    {
        $entity = static::getEntity();
        $parameters = $entity->prepareTabletQueryParameters($parameters);
        $entity->result = $entity->getTablet()->getList($parameters);
 
        return $entity;
    }
 
    public static function getRow(array $parameters): ?array
    {
        $parameters['limit'] = 1;
        $result = static::getList($parameters);
        $row = $result->fetch();
 
        return (is_array($row) ? $row : null);
    }
 
    public function fetch(Main\Text\Converter $converter = null)
    {
        if ($this->result === null)
            return false;
        $row = $this->result->fetch($converter);
        if (!$row)
        {
            $this->result = null;
            $this->fetchCutMask = [];
            return false;
        }
        if (empty($this->fields))
            return $row;
        if (!isset($row['ID']))
            return $row;
 
        $this->setEntityCacheItem((int)$row['ID'], $row, true);
        if (!empty($this->fetchCutMask))
            $row = array_diff_key($row, $this->fetchCutMask);
        return $row;
    }
 
    public static function clearCache(): void
    {
        static::getEntity()->clearEntityCache();
    }
 
    public static function add(array $data): ORM\Data\AddResult
    {
        $result = new ORM\Data\AddResult();
 
        $entity = static::getEntity();
 
        static::normalize($data);
 
        if (Event::existEventHandlers($entity, ORM\Data\DataManager::EVENT_ON_BEFORE_ADD))
        {
            $event = new Event(
                $entity,
                ORM\Data\DataManager::EVENT_ON_BEFORE_ADD,
                $data
            );
            $event->send();
 
            $event->mergeData($data);
            if ($event->getErrors($result))
                return $result;
        }
 
        static::prepareForAdd($result, null, $data);
        if (!$result->isSuccess())
            return $result;
        unset($result);
 
        if (Event::existEventHandlers($entity, ORM\Data\DataManager::EVENT_ON_ADD))
        {
            $event = new Event(
                $entity,
                ORM\Data\DataManager::EVENT_ON_ADD,
                $data
            );
            $event->send();
            unset($event);
        }
 
        $result = $entity->getTablet()->add($data['fields']);
        $success = $result->isSuccess();
        if ($success)
        {
            $data['fields'] = $result->getData();
            if ($entity->fieldsCount > 0)
                $entity->setEntityCacheItem((int)$result->getId(), $result->getData(), false);
        }
 
        if (Event::existEventHandlers($entity, ORM\Data\DataManager::EVENT_ON_AFTER_ADD))
        {
            $event = new Event(
                $entity,
                ORM\Data\DataManager::EVENT_ON_AFTER_ADD,
                [
                    'id' => $result->getId(),
                    'fields' => $data['fields'],
                    'external_fields' => $data['external_fields'],
                    'actions' => $data['actions'],
                    'success' => $success
                ]
            );
            $event->send();
            unset($event);
        }
 
        if ($success && !empty($data['actions']))
            static::runAddExternalActions($result->getId(), $data);
 
        unset($success, $entity);
 
        return $result;
    }
 
    public static function update($id, array $data): ORM\Data\UpdateResult
    {
        $result = new ORM\Data\UpdateResult();
 
        $entity = static::getEntity();
 
        static::normalize($data);
 
        if (Event::existEventHandlers($entity, ORM\Data\DataManager::EVENT_ON_BEFORE_UPDATE))
        {
            $event = new Event(
                $entity,
                ORM\Data\DataManager::EVENT_ON_BEFORE_UPDATE,
                [
                    'id' => $id,
                    'fields' => $data['fields'],
                    'external_fields' => $data['external_fields'],
                    'actions' => $data['actions']
                ]
            );
            $event->send();
 
            $event->mergeData($data);
            if ($event->getErrors($result))
                return $result;
        }
 
        static::prepareForUpdate($result, $id, $data);
        if (!$result->isSuccess())
            return $result;
        unset($result);
 
        if (Event::existEventHandlers($entity, ORM\Data\DataManager::EVENT_ON_UPDATE))
        {
            $event = new Event(
                $entity,
                ORM\Data\DataManager::EVENT_ON_UPDATE,
                [
                    'id' => $id,
                    'fields' => $data['fields'],
                    'external_fields' => $data['external_fields'],
                    'actions' => $data['actions']
                ]
            );
            $event->send();
            unset($event);
        }
 
        $result = $entity->getTablet()->update($id, $data['fields']);
        $success = $result->isSuccess();
        if ($success)
        {
            $data['fields'] = $result->getData();
            if ($entity->fieldsCount > 0)
                $entity->modifyEntityCacheItem($id, $data['fields']);
        }
 
        if (Event::existEventHandlers($entity, ORM\Data\DataManager::EVENT_ON_AFTER_UPDATE))
        {
            $event = new Event(
                $entity,
                ORM\Data\DataManager::EVENT_ON_AFTER_UPDATE,
                [
                    'id' => $id,
                    'fields' => $data['fields'],
                    'external_fields' => $data['external_fields'],
                    'actions' => $data['actions'],
                    'success' => $success
                ]
            );
            $event->send();
            unset($event);
        }
 
        if ($success && !empty($data['actions']))
            static::runUpdateExternalActions($id, $data);
 
        unset($success, $entity);
 
        return $result;
    }
 
    public static function delete($id): ORM\Data\DeleteResult
    {
        $result = new ORM\Data\DeleteResult();
 
        $entity = static::getEntity();
 
        if (Event::existEventHandlers($entity, ORM\Data\DataManager::EVENT_ON_BEFORE_DELETE))
        {
            $event = new Event(
                $entity,
                ORM\Data\DataManager::EVENT_ON_BEFORE_DELETE,
                ['id' => $id]
            );
            $event->send();
 
            if ($event->getErrors($result))
                return $result;
        }
 
        if (Event::existEventHandlers($entity, ORM\Data\DataManager::EVENT_ON_DELETE))
        {
            $event = new Event(
                $entity,
                ORM\Data\DataManager::EVENT_ON_DELETE,
                ['id' => $id]
            );
            $event->send();
            unset($event);
        }
 
        if ($entity->fieldsCount > 0 && !isset($entity->cache[$id]))
            $entity->loadEntityCacheItem($id);
 
        $result = $entity->getTablet()->delete($id);
        $success = $result->isSuccess();
        if ($success)
            $entity->expireEntityCacheItem((int)$id);
 
        if (Event::existEventHandlers($entity, ORM\Data\DataManager::EVENT_ON_AFTER_DELETE))
        {
            $event = new Event(
                $entity,
                ORM\Data\DataManager::EVENT_ON_AFTER_DELETE,
                ['id' => $id, 'success' => $success]
            );
            $event->send();
            unset($event);
        }
 
        if ($success)
            static::runDeleteExternalActions($id);
 
        unset($success, $entity);
 
        return $result;
    }
 
    public static function setCacheItem($id, array $row): void
    {
        $id = (int)$id;
        if ($id <= 0 || empty($row))
            return;
        static::getEntity()->setEntityCacheItem($id, $row, false);
    }
 
    public static function getCacheItem($id, bool $load = false): ?array
    {
        $id = (int)$id;
        if ($id <= 0)
            return null;
        return static::getEntity()->getEntityCacheItem($id, $load);
    }
 
    public static function clearCacheItem($id): void
    {
        $id = (int)$id;
        if ($id <= 0)
            return;
        static::getEntity()->clearEntityCacheItem($id);
    }
 
    public static function getTabletClassName(): string
    {
        return '';
    }
 
    public static function getTabletFieldNames(int $fields = self::FIELDS_MAIN): array
    {
        $result = [];
        $entity = static::getEntity();
        if ($fields & self::FIELDS_MAIN)
        {
            $result = array_keys($entity->tabletFields);
        }
        if ($fields & self::FIELDS_UF)
        {
            $list = array_keys($entity->tabletUserFields);
            if (!empty($list))
            {
                $result = (empty($result)
                    ? $list
                    : array_merge($result, $list)
                );
            }
            unset($list);
        }
 
        unset($entity);
        return $result;
    }
 
    public static function getCachedFieldList(): array
    {
        $entity = static::getEntity();
        return $entity->fields;
    }
 
    protected function getTablet(): ORM\Data\DataManager
    {
        if (!($this->tablet instanceof ORM\Data\DataManager))
            throw new Main\ObjectNotFoundException(sprintf(
                'Tablet not found in entity `%s`',
                get_class($this)
            ));
        return $this->tablet;
    }
 
    protected static function prepareForAdd(ORM\Data\AddResult $result, $id, array &$data): void
    {
        $data = static::getEntity()->checkTabletWhiteList($data);
        if (empty($data))
        {
            $result->addError(new ORM\EntityError(sprintf(
                'Empty data for add in entity `%s`',
                get_called_class()
            )));
        }
    }
 
    protected static function prepareForUpdate(ORM\Data\UpdateResult $result, $id, array &$data): void
    {
        $data = static::getEntity()->checkTabletWhiteList($data);
        if (empty($data))
        {
            $result->addError(new ORM\EntityError(sprintf(
                'Empty data for update in entity `%s`',
                get_called_class()
            )));
        }
    }
 
    protected static function deleteNoDemands($id): ORM\Data\DeleteResult
    {
        $entity = static::getEntity();
 
        if ($entity->fieldsCount > 0 && !isset($entity->cache[$id]))
            $entity->loadEntityCacheItem($id);
 
        $result = $entity->getTablet()->delete($id);
        if ($result->isSuccess())
        {
            if ($entity->fieldsCount > 0)
                $entity->expireEntityCacheItem((int)$id);
            static::runDeleteExternalActions($id);
        }
 
        unset($entity);
 
        return $result;
    }
 
    protected static function normalize(array &$data): void
    {
        $result = [
            'fields' => [],
            'external_fields' => [],
            'actions' => []
        ];
 
        if (isset($data['fields']) && is_array($data['fields']))
        {
            $result['fields'] = $data['fields'];
            if (isset($data['external_fields']) && is_array($data['external_fields']))
                $result['external_fields'] = $data['external_fields'];
            if (isset($data['actions']) && is_array($data['actions']))
                $result['actions'] = $data['actions'];
        }
        else
        {
            $result['fields'] = $data;
        }
 
        $data = $result;
        unset($result);
    }
 
    protected static function runAddExternalActions($id, array $data): void {}
 
    protected static function runUpdateExternalActions($id, array $data): void {}
 
    protected static function runDeleteExternalActions($id): void {}
 
    protected static function getDefaultCachedFieldList(): array
    {
        return [];
    }
 
    private function initEntityTablet(): void
    {
        $tabletClassName = static::getTabletClassName();
        $this->tablet = new $tabletClassName;
        $this->tabletFields = [];
        $this->tabletUserFields = [];
 
        $entity = $this->tablet->getEntity();
        $checkUseFields = $entity->getUfId() !== null;
        $list = $entity->getFields();
        foreach ($list as $field)
        {
            if ($field instanceof ORM\Fields\ScalarField)
            {
                $this->tabletFields[$field->getName()] = true;
            }
            elseif ($checkUseFields && $field instanceof ORM\Fields\UserTypeField)
            {
                $this->tabletUserFields[$field->getName()] = true;
            }
        }
        unset($field, $list);
        unset($checkUseFields);
        unset($entity, $tabletClassName);
    }
 
    private function initEntityCache(): void
    {
        $this->clearEntityCache();
 
        $this->aliases = [];
        $this->fieldMask = [];
        $fieldList = static::getDefaultCachedFieldList();
        if (Event::existEventHandlers($this, self::EVENT_ON_BUILD_CACHED_FIELD_LIST))
        {
            $event = new Event(
                $this,
                self::EVENT_ON_BUILD_CACHED_FIELD_LIST
            );
            $event->send();
 
            foreach($event->getResults() as $eventResult)
            {
                if ($eventResult->getType() == Main\EventResult::SUCCESS)
                {
                    $addFields = $eventResult->getParameters();
                    if (!empty($addFields) && is_array($addFields))
                    {
                        foreach ($addFields as $alias => $field)
                        {
                            if (!isset($this->tabletFields[$field]))
                            {
                                continue;
                            }
                            $index = array_search($field, $fieldList);
                            if (is_int($alias))
                            {
                                if ($index === false || !is_int($index))
                                {
                                    $fieldList[] = $field;
                                }
                            }
                            else
                            {
                                if ($index !== $alias)
                                {
                                    $fieldList[$alias] = $field;
                                }
                            }
                        }
                    }
                }
            }
            unset($eventResult, $event);
        }
 
        $this->fields = $fieldList;
        unset($fieldList);
        if (!empty($this->fields))
        {
            foreach ($this->fields as $alias => $field)
            {
                if (is_int($alias))
                {
                    $this->fieldMask[$field] = true;
                }
                else
                {
                    $this->fieldMask[$alias] = true;
                    $this->aliases[$alias] = $field;
                }
            }
            unset($alias, $field);
        }
        $this->fieldsCount = count($this->fields);
    }
 
    private function clearEntityCache(): void
    {
        $this->cache = [];
        $this->cacheModifyed = [];
    }
 
    private function prepareTabletQueryParameters(array $parameters): array
    {
        $this->fetchCutMask = [];
 
        if (empty($this->fields))
            return $parameters;
        if (!isset($parameters['select']))
            return $parameters;
        if (in_array('*', $parameters['select']))
            return $parameters;
        if (isset($parameters['group']))
            return $parameters;
 
        $select = $parameters['select'];
        foreach ($this->fields as $field)
        {
            $existField = false;
            $index = array_search($field, $select);
            if ($index !== false && is_int($index))
                $existField = true;
            if ($existField)
                continue;
 
            $parameters['select'][] = $field;
            $this->fetchCutMask[$field] = true;
        }
        unset($index, $existField, $field);
 
        return $parameters;
    }
 
    private function replaceFieldToAlias(array &$row): void
    {
        if (empty($this->aliases))
            return;
 
        foreach ($this->aliases as $alias => $field)
        {
            $row[$alias] = $row[$field];
            unset($row[$field]);
        }
        unset($alias, $field);
    }
 
    private function checkTabletWhiteList(array $fields): array
    {
        $baseFields = array_intersect_key($fields, $this->tabletFields);
        if (!empty($this->tabletUserFields))
        {
            $userFields = array_intersect_key($fields, $this->tabletUserFields);
            if (!empty($userFields))
            {
                $baseFields = $baseFields + $userFields;
            }
            unset($userFields);
        }
        return $baseFields;
    }
 
    static public function getCallbackRestEvent(): array
    {
        return [Main\Rest\Event::class, 'processItemEvent'];
    }
 
    /* entity cache item tools */
 
    private function loadEntityCacheItem($id): void
    {
        if (isset($this->cache[$id]))
            return;
        if (empty($this->fields))
            return;
 
        $iterator = $this->getTablet()->getList([
            'select' => array_values($this->fields),
            'filter' => ['=ID' => $id]
        ]);
        $row = $iterator->fetch();
        unset($iterator);
        if (!empty($row))
            $this->setEntityCacheItem($id, $row, true);
        unset($row);
    }
 
    private function getEntityCacheItem($id, bool $load = false): array
    {
        $result = [];
        if (!isset($this->cache[$id]) && $load && !empty($this->fields))
            $this->loadEntityCacheItem($id);
        if (isset($this->cache[$id]))
            $result = $this->cache[$id];
 
        return $result;
    }
 
    private function setEntityCacheItem($id, array $row, bool $replaceAliases = false): void
    {
        if (empty($this->fieldMask))
            return;
        if (isset($this->cache[$id]))
            return;
 
        if ($replaceAliases)
            $this->replaceFieldToAlias($row);
        $data = array_intersect_key($row, $this->fieldMask);
        if (!empty($data) && count($data) == $this->fieldsCount)
            $this->cache[$id] = $data;
        unset($data);
    }
 
    private function modifyEntityCacheItem($id, array $row): void
    {
        if (empty($this->fieldMask))
            return;
 
        $data = array_intersect_key($row, $this->fieldMask);
        if (!empty($data))
        {
            if (!isset($this->cache[$id]))
                $this->loadEntityCacheItem($id);
            if (isset($this->cache[$id]))
            {
                $this->expireEntityCacheItem($id, true);
                $this->cache[$id] = array_merge($this->cache[$id], $data);
            }
        }
        unset($data);
    }
 
    private function expireEntityCacheItem($id, bool $copy = false): void
    {
        if (empty($this->fields))
            return;
 
        if (!isset($this->cache[$id]))
            return;
        if (isset($this->cacheModifyed[$id]))
            return;
 
        $oldData = [];
        foreach (array_keys($this->fieldMask) as $field)
            $oldData[self::PREFIX_OLD.$field] = $this->cache[$id][$field];
        unset($field);
        if ($copy)
            $this->cache[$id] = array_merge($oldData, $this->cache[$id]);
        else
            $this->cache[$id] = $oldData;
        unset($oldData);
 
        $this->cacheModifyed[$id] = true;
    }
 
    private function clearEntityCacheItem($id): void
    {
        if (isset($this->cache[$id]))
            unset($this->cache[$id]);
        if (isset($this->cacheModifyed[$id]))
            unset($this->cacheModifyed[$id]);
    }
 
    public static function clearSettings(): void {}
 
    /* entity cache item tools end */
 
    protected static function prepareFloatValue($value): ?float
    {
        if ($value === null)
        {
            return null;
        }
 
        $result = null;
        if (is_string($value))
        {
            if ($value !== '' && is_numeric($value))
            {
                $value = (float)$value;
                if (is_finite($value))
                {
                    $result = $value;
                }
            }
        }
        else
        {
            if (is_int($value))
            {
                $value = (float)$value;
            }
            if (
                is_float($value) && is_finite($value)
            )
            {
                $result = $value;
            }
        }
 
        return $result;
    }
 
    protected static function prepareIntValue($value): ?int
    {
        if ($value === null)
        {
            return null;
        }
 
        $result = null;
        if (is_string($value))
        {
            if ($value !== '' && is_numeric($value))
            {
                $result = (int)$value;
            }
        }
        elseif (is_int($value))
        {
            $result = $value;
        }
 
        return $result;
    }
 
    protected static function prepareStringValue($value): ?string
    {
        if (is_string($value))
        {
            return trim($value) ?: null;
        }
 
        return null;
    }
}