fieldtype.php

<?php
namespace Bitrix\Bizproc;
 
use Bitrix\Bizproc\BaseType\Base;
use Bitrix\Main;
 
class FieldType
{
 
    public const BOOL = 'bool';
 
    public const DATE = 'date';
 
    public const DATETIME = 'datetime';
 
    public const DOUBLE = 'double';
 
    public const FILE = 'file';
 
    public const INT = 'int';
 
    public const SELECT = 'select';
 
    public const INTERNALSELECT = 'internalselect';
 
    public const STRING = 'string';
 
    public const TEXT = 'text';
 
    public const USER = 'user';
 
    public const TIME = 'time';
 
    public const RENDER_MODE_DESIGNER = 1;
 
    public const RENDER_MODE_ADMIN = 2;
 
    public const RENDER_MODE_MOBILE = 4;
 
    public const RENDER_MODE_PUBLIC = 8;
 
    public const RENDER_MODE_JN_MOBILE = 16;
 
    public const VALUE_CONTEXT_DOCUMENT = 'Document';
    public const VALUE_CONTEXT_REST = 'rest';
    public const VALUE_CONTEXT_JN_MOBILE = 'jn_mobile';
 
    protected $typeClass;
 
    protected $property;
 
    protected $documentType;
 
    protected $documentId;
 
    public function __construct(array $property, array $documentType, $typeClass, array $documentId = null)
    {
        $this->property = static::normalizeProperty($property);
        $this->documentType = $documentType;
 
        $this->typeClass = $typeClass;
        $this->documentId = $documentId;
    }
 
    public function getProperty()
    {
        return $this->property;
    }
 
    public function getType()
    {
        return isset($this->property['Type']) ? $this->property['Type'] : null;
    }
 
    public function getBaseType()
    {
        $class = $this->typeClass;
        return $class::getType();
    }
 
    public function getTypeClass()
    {
        return $this->typeClass;
    }
 
    public function setTypeClass($typeClass)
    {
        if (is_subclass_of($typeClass, '\Bitrix\Bizproc\BaseType\Base'))
        {
            $this->typeClass = $typeClass;
        }
        else
            throw new Main\ArgumentException('Incorrect type class.');
 
        return $this;
    }
 
    public function getDocumentType()
    {
        return $this->documentType;
    }
 
    public function setDocumentType(array $documentType)
    {
        $this->documentType = $documentType;
        return $this;
    }
 
    public function getDocumentId()
    {
        return $this->documentId;
    }
 
    public function setDocumentId(array $documentId)
    {
        $this->documentId = $documentId;
        return $this;
    }
 
    public function isMultiple()
    {
        return !empty($this->property['Multiple']);
    }
 
    public function setMultiple($value)
    {
        $this->property['Multiple'] = (bool)$value;
        return $this;
    }
 
    public function isRequired()
    {
        return !empty($this->property['Required']);
    }
 
    public function getOptions()
    {
        return isset($this->property['Options']) ? $this->property['Options'] : null;
    }
 
    public function setOptions($options)
    {
        $this->property['Options'] = $options;
        return $this;
    }
 
    public function getSettings()
    {
        return isset($this->property['Settings']) && is_array($this->property['Settings'])
            ? $this->property['Settings'] : array();
    }
 
    public function setSettings(array $settings)
    {
        $this->property['Settings'] = $settings;
        return $this;
    }
 
    public function getName()
    {
        return $this->property['Name'];
    }
 
    public function getDescription()
    {
        return $this->property['Description'];
    }
 
    public function formatValue($value, $format = 'printable')
    {
        $typeClass = $this->typeClass;
 
        if ($this->isMultiple())
        {
            return $typeClass::formatValueMultiple($this, $value, $format);
        }
        else
        {
            return $typeClass::formatValueSingle($this, $value, $format);
        }
    }
 
    public function convertValue($value, $toTypeClass)
    {
        $typeClass = $this->typeClass;
 
        if ($this->isMultiple())
        {
            return $typeClass::convertValueMultiple($this, $value, $toTypeClass);
        }
        else
        {
            return $typeClass::convertValueSingle($this, $value, $toTypeClass);
        }
    }
 
    public function mergeValue($baseValue, $appendValue): array
    {
        $typeClass = $this->typeClass;
        $baseValue = (array) $baseValue;
 
        if ($this->isMultiple() && !\CBPHelper::isEmptyValue($appendValue))
        {
            return $typeClass::mergeValue($this, $baseValue, $appendValue);
        }
 
        return $baseValue;
    }
 
    public function canRenderControl($renderMode)
    {
        $typeClass = $this->typeClass;
        return $typeClass::canRenderControl($renderMode);
    }
 
    public function renderControl(array $field, $value, $allowSelection, $renderMode)
    {
        $typeClass = $this->typeClass;
 
        if ($this->isMultiple())
        {
            return $typeClass::renderControlMultiple($this, $field, $value, $allowSelection, $renderMode);
        }
        else
        {
            return $typeClass::renderControlSingle($this, $field, $value, $allowSelection, $renderMode);
        }
    }
 
    public function renderControlOptions($callbackFunctionName, $value)
    {
        $typeClass = $this->typeClass;
        return $typeClass::renderControlOptions($this, $callbackFunctionName, $value);
    }
 
    public function extractValue(array $field, array $request, array &$errors = null)
    {
        $typeClass = $this->typeClass;
 
        if ($this->isMultiple())
        {
            $result = $typeClass::extractValueMultiple($this, $field, $request);
        }
        else
        {
            $result = $typeClass::extractValueSingle($this, $field, $request);
        }
        $errors = $typeClass::getErrors();
 
        return $result;
    }
 
    public function clearValue($value)
    {
        $typeClass = $this->typeClass;
 
        if ($this->isMultiple())
        {
            $typeClass::clearValueMultiple($this, $value);
        }
        else
        {
            $typeClass::clearValueSingle($this, $value);
        }
    }
 
    public function internalizeValue($context, $value)
    {
        $typeClass = $this->typeClass;
 
        if ($this->isMultiple())
        {
            return $typeClass::internalizeValueMultiple($this, $context, $value);
        }
        else
        {
            return $typeClass::internalizeValueSingle($this, $context, $value);
        }
    }
 
    public function externalizeValue($context, $value)
    {
        $typeClass = $this->typeClass;
 
        if ($this->isMultiple())
        {
            return $typeClass::externalizeValueMultiple($this, $context, $value);
        }
        else
        {
            return $typeClass::externalizeValueSingle($this, $context, $value);
        }
    }
 
    public static function getBaseTypesMap()
    {
        return array(
            static::BOOL => BaseType\BoolType::class,
            static::DATE => BaseType\Date::class,
            static::DATETIME => BaseType\Datetime::class,
            static::DOUBLE => BaseType\Double::class,
            static::FILE => BaseType\File::class,
            static::INT => BaseType\IntType::class,
            static::SELECT => BaseType\Select::class,
            static::STRING => BaseType\StringType::class,
            static::TEXT => BaseType\Text::class,
            static::USER => BaseType\User::class,
            static::INTERNALSELECT => BaseType\InternalSelect::class,
            static::TIME => BaseType\Time::class,
        );
    }
 
    public static function isBaseType(string $type): bool
    {
        return array_key_exists($type, static::getBaseTypesMap());
    }
 
    public static function convertUfType(string $type): ?string
    {
        $bpType = null;
        switch ($type)
        {
            case 'string':
            case 'datetime':
            case 'date':
            case 'double':
            case 'file':
                $bpType = $type;
                break;
            case 'integer':
                $bpType = 'int';
                break;
            case 'boolean':
                $bpType = 'bool';
                break;
            case 'employee':
                $bpType = 'user';
                break;
            case 'enumeration':
                $bpType = 'select';
                break;
            case 'money':
            case 'url':
            case 'address':
            case 'resourcebooking':
            case 'crm_status':
            case 'iblock_section':
            case 'iblock_element':
            case 'crm':
                $bpType = "UF:{$type}";
                break;
        }
 
        return $bpType;
    }
 
    public static function normalizeProperty($property)
    {
        $normalized = [
            'Id' => null,
            'Type' => null,
 
            'Name' => null,
            'Description' => null,
 
            'Multiple' => false,
            'Required' => false,
 
            'Options' => null,
            'Settings' => null,
            'Default' => null,
        ];
 
        if (!is_array($property))
        {
            $normalized['Type'] = (string) $property;
 
            return $normalized;
        }
 
        foreach ($property as $key => $val)
        {
            switch(mb_strtoupper($key))
            {
                case 'TYPE':
                case '0':
                    $normalized['Type'] = (string)$val;
                    break;
                case 'MULTIPLE':
                case '1':
                    $normalized['Multiple'] = \CBPHelper::getBool($val);
                    break;
                case 'REQUIRED':
                case '2':
                    $normalized['Required'] = \CBPHelper::getBool($val);
                    break;
                case 'OPTIONS':
                case '3':
                    $normalized['Options'] = is_array($val)? $val : (string)$val;
                    break;
                case 'SETTINGS':
                    $normalized['Settings'] = is_array($val) ? $val : null;
                    break;
                case 'ID':
                    $normalized['Id'] = (string)$val;
                    break;
                case 'NAME':
                case 'TITLE':
                    $normalized['Name'] = (string)$val;
                    break;
                case 'DESCRIPTION':
                    $normalized['Description'] = (string)$val;
                    break;
                case 'DEFAULT':
                    $normalized['Default'] = $val;
                    break;
            }
        }
 
        return $normalized;
    }
 
    public function setValue($value)
    {
        $typeClass = $this->typeClass;
 
        $this->property['Default'] =
            ($this->isMultiple())
                ? $typeClass::validateValueMultiple($value, $this)
                : $typeClass::validateValueSingle($value, $this)
        ;
    }
 
    public function getValue()
    {
        return $this->property['Default'];
    }
 
    public function convertPropertyToView(int $viewMode): array
    {
        $typeClass = $this->typeClass;
 
        return $typeClass::convertPropertyToView($this, $viewMode, $this->getProperty());
    }
}