field.php

<?php
namespace Bitrix\Main\ORM\Fields;
use Bitrix\Main\Application;
use Bitrix\Main\DB\SqlExpression;
use Bitrix\Main\ORM\Entity;
use Bitrix\Main\ORM\EntityError;
use Bitrix\Main\ORM\Data\Result;
use Bitrix\Main\ORM\Fields\Validators\IValidator;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\SystemException;
 
abstract class Field
{
    protected $name;
 
    protected $dataType;
 
    protected $initialParameters;
 
    protected $title;
 
    protected $validation = null;
 
    protected $validators = null;
 
    protected $additionalValidators = array();
 
    protected $fetchDataModification = null;
 
    protected $fetchDataModifiers;
 
    protected $additionalFetchDataModifiers = array();
 
    protected $saveDataModification = null;
 
    protected $saveDataModifiers;
 
    protected $additionalSaveDataModifiers = array();
 
    protected $isSerialized = false;
 
    protected $parentField;
 
    protected $entity;
 
    protected static $oldDataTypes = array(
        'float' => 'Bitrix\Main\ORM\Fields\FloatField',
        'string' => 'Bitrix\Main\ORM\Fields\StringField',
        'text' => 'Bitrix\Main\ORM\Fields\TextField',
        'datetime' => 'Bitrix\Main\ORM\Fields\DatetimeField',
        'date' => 'Bitrix\Main\ORM\Fields\DateField',
        'integer' => 'Bitrix\Main\ORM\Fields\IntegerField',
        'enum' => 'Bitrix\Main\ORM\Fields\EnumField',
        'boolean' => 'Bitrix\Main\ORM\Fields\BooleanField'
    );
 
    public function __construct($name, $parameters = array())
    {
        if ($name == '')
        {
            throw new SystemException('Field name required');
        }
 
        $this->name = $name;
        $this->dataType = null;
        $this->initialParameters = $parameters;
 
        if (isset($parameters['title']))
        {
            $this->title = $parameters['title'];
        }
 
        // validation
        if (isset($parameters['validation']))
        {
            $this->validation = $parameters['validation'];
        }
 
        // fetch data modifiers
        if (isset($parameters['fetch_data_modification']))
        {
            $this->fetchDataModification = $parameters['fetch_data_modification'];
        }
 
        // save data modifiers
        if (isset($parameters['save_data_modification']))
        {
            $this->saveDataModification = $parameters['save_data_modification'];
        }
 
        if (!empty($parameters['serialized']))
        {
            $this->setSerialized();
        }
    }
 
    public function setEntity(Entity $entity)
    {
        if ($this->entity !== null)
        {
            throw new SystemException(sprintf('Field "%s" already has entity', $this->name));
        }
 
        $this->entity = $entity;
    }
 
    public function resetEntity()
    {
        $this->entity = null;
    }
 
    abstract public function getTypeMask();
 
    public function validateValue($value, $primary, $row, Result $result)
    {
        if ($value instanceof SqlExpression)
        {
            return $result;
        }
 
        $validators = $this->getValidators();
 
        foreach ($validators as $validator)
        {
            if ($validator instanceof IValidator)
            {
                $vResult = $validator->validate($value, $primary, $row, $this);
            }
            else
            {
                $vResult = call_user_func_array($validator, array($value, $primary, $row, $this));
            }
 
            if ($vResult !== true)
            {
                if ($vResult instanceof EntityError)
                {
                    $result->addError($vResult);
                }
                else
                {
                    $result->addError(new FieldError($this, $vResult, FieldError::INVALID_VALUE));
                }
            }
        }
 
        return $result;
    }
 
    public function modifyValueBeforeSave($value, $data)
    {
        $modifiers = $this->getSaveDataModifiers();
 
        foreach ($modifiers as $modifier)
        {
            $value = call_user_func_array($modifier, array($value, $data));
        }
 
        return $value;
    }
 
    public function getValidators()
    {
        if ($this->validators === null)
        {
            $this->validators = array();
 
            if ($this->validation !== null)
            {
                $validators = call_user_func($this->validation);
 
                if (!is_array($validators))
                {
                    throw new SystemException(sprintf(
                        'Validation for %s field of %s entity should return array of validators',
                        $this->name, $this->entity->getDataClass()
                    ));
                }
 
                foreach ($validators as $validator)
                {
                    $this->appendValidator($validator);
                }
            }
 
            foreach ($this->additionalValidators as $validator)
            {
                $this->appendValidator($validator);
            }
        }
 
        return $this->validators;
    }
 
    public function addValidator($validator)
    {
        // append only when not null. and when is null - delay it
        if ($this->validators === null)
        {
            $this->additionalValidators[] = $validator;
        }
        else
        {
            $this->appendValidator($validator);
        }
 
        return $this;
    }
 
    protected function appendValidator($validator)
    {
        if (!($validator instanceof Validators\Validator) && !is_callable($validator))
        {
            throw new SystemException(sprintf(
                'Validators of "%s" field of "%s" entity should be a Validator\Base or callback',
                $this->name, $this->entity->getDataClass()
            ));
        }
 
        $this->validators[] = $validator;
    }
 
    public function getFetchDataModifiers()
    {
        if ($this->fetchDataModifiers === null)
        {
            $this->fetchDataModifiers = array();
 
            if ($this->fetchDataModification !== null)
            {
                $modifiers = call_user_func($this->fetchDataModification);
 
                if (!is_array($modifiers))
                {
                    throw new SystemException(sprintf(
                        'Fetch Data Modification for %s field of %s entity should return array of modifiers (callbacks)',
                        $this->name, $this->entity->getDataClass()
                    ));
                }
 
                foreach ($modifiers as $modifier)
                {
                    $this->appendFetchDataModifier($modifier);
                }
            }
 
            foreach ($this->additionalFetchDataModifiers as $modifier)
            {
                $this->appendFetchDataModifier($modifier);
            }
        }
 
        return $this->fetchDataModifiers;
    }
 
    public function addFetchDataModifier($modifier)
    {
        // append only when not null. and when is null - delay it
        if ($this->fetchDataModifiers === null)
        {
            $this->additionalFetchDataModifiers[] = $modifier;
        }
        else
        {
            $this->appendFetchDataModifier($modifier);
        }
 
        return $this;
    }
 
    protected function appendFetchDataModifier($modifier)
    {
        if (!is_callable($modifier))
        {
            throw new SystemException(sprintf(
                'Modifier of "%s" field of "%s" entity should be a callback',
                $this->name, $this->entity->getDataClass()
            ));
        }
 
        $this->fetchDataModifiers[] = $modifier;
    }
 
    public function getSaveDataModifiers()
    {
        if ($this->saveDataModifiers === null)
        {
            $this->saveDataModifiers = array();
 
            if ($this->saveDataModification !== null)
            {
                $modifiers = call_user_func($this->saveDataModification);
 
                if (!is_array($modifiers))
                {
                    throw new SystemException(sprintf(
                        'Save Data Modification for %s field of %s entity should return array of modifiers (callbacks)',
                        $this->name, $this->entity->getDataClass()
                    ));
                }
 
                foreach ($modifiers as $modifier)
                {
                    $this->appendSaveDataModifier($modifier);
                }
            }
 
            foreach ($this->additionalSaveDataModifiers as $modifier)
            {
                $this->appendSaveDataModifier($modifier);
            }
        }
 
        return $this->saveDataModifiers;
    }
 
    public function addSaveDataModifier($modifier)
    {
        // append only when not null. and when is null - delay it
        if ($this->saveDataModifiers === null)
        {
            $this->additionalSaveDataModifiers[] = $modifier;
        }
        else
        {
            $this->appendSaveDataModifier($modifier);
        }
 
        return $this;
    }
 
    protected function appendSaveDataModifier($modifier)
    {
        if (!is_callable($modifier))
        {
            throw new SystemException(sprintf(
                'Save modifier of "%s" field of "%s" entity should be a callback',
                $this->name, $this->entity->getDataClass()
            ));
        }
 
        $this->saveDataModifiers[] = $modifier;
    }
 
    public function isSerialized()
    {
        return !empty($this->isSerialized);
    }
 
    public function setSerialized()
    {
        if (!$this->isSerialized)
        {
            $this->isSerialized = true;
 
            // add save- and fetch modifiers
            $this->addSaveDataModifier(array($this, 'serialize'));
            $this->addFetchDataModifier(array($this, 'unserialize'));
        }
    }
 
    public function configureSerialized()
    {
        $this->setSerialized();
        return $this;
    }
 
    public function getName()
    {
        return $this->name;
    }
 
    public function setName($name)
    {
        $this->name = $name;
    }
 
    public function configureTitle($title)
    {
        $this->title = $title;
        return $this;
    }
 
    public function getTitle()
    {
        if($this->title !== null)
        {
            return $this->title;
        }
 
        if(($title = Loc::getMessage($this->getLangCode())) <> '')
        {
            return $this->title = $title;
        }
 
        return $this->title = $this->name;
    }
 
    public function setParameter($name, $value)
    {
        $this->initialParameters[$name] = $value;
 
        return $this;
    }
 
    public function getParameter($name)
    {
        return $this->initialParameters[$name];
    }
 
    public function hasParameter($name)
    {
        return array_key_exists($name, $this->initialParameters);
    }
 
    public function setParentField(Field $parentField)
    {
        $this->parentField = $parentField;
    }
 
    public function getParentField()
    {
        return $this->parentField;
    }
 
    public function getDataType()
    {
        if (empty($this->dataType))
        {
            return static::getOldDataTypeByField($this);
        }
 
        return $this->dataType;
    }
 
    public static function getOldDataTypeByClass($class)
    {
        $map = array_flip(static::$oldDataTypes);
 
        return $map[$class] ?? 'string';
    }
 
    public static function getOldDataTypeByField(Field $field)
    {
        return static::getOldDataTypeByClass(get_class($field));
    }
 
    public static function getClassByOldDataType($dateType)
    {
        return isset(static::$oldDataTypes[$dateType]) ? '\\'.static::$oldDataTypes[$dateType] : false;
    }
 
    public function getEntity()
    {
        return $this->entity;
    }
 
    public function getLangCode()
    {
        $entity = $this->getEntity();
        if($entity !== null)
        {
            return $entity->getLangCode().'_'.$this->getName().'_FIELD';
        }
        return null;
    }
 
    public function getConnection()
    {
        if ($this->entity)
        {
            return $this->entity->getConnection();
        }
 
        return Application::getConnection();
    }
 
    public function serialize($value)
    {
        return serialize($value);
    }
 
    public function unserialize($value)
    {
        return unserialize((string)$value);
    }
 
    public function postInitialize()
    {
        return null;
    }
}