class.arFieldList.php

Go to the documentation of this file.

<?php
require_once('class.arField.php');
 
class arFieldList
{
    const HAS_FIELD = 'has_field';
    const IS_UNIQUE = 'is_unique';
    const IS_PRIMARY = 'is_primary';
    const IS_NOTNULL = 'is_notnull';
    const FIELDTYPE = 'fieldtype';
    const LENGTH = 'length';
    const SEQUENCE = 'sequence';
    const INDEX = 'index';
    protected static $prefixes = array( 'db', 'con' );
    protected static $protected_names = array( 'arConnector', 'arFieldList' );
    protected static $allowed_description_fields = array(
        self::IS_UNIQUE,
        self::IS_PRIMARY,
        self::IS_NOTNULL,
        self::FIELDTYPE,
        self::LENGTH,
        self::SEQUENCE,
        self::INDEX,
    );
    protected static $allowed_connector_fields = array(
        self::IS_NOTNULL,
        self::FIELDTYPE,
        self::LENGTH,
    );
    protected $primary_field;
    protected $primary_fields = array();
    protected $raw_fields = array();
    protected $fields = array();
    protected $ar;
    protected static $key_maps = array(
        self::FIELDTYPE => 'type',
        self::IS_NOTNULL => 'notnull',
    );
 
 
    public function __construct(ActiveRecord $ar)
    {
        $this->ar = $ar;
    }
 
 
    public static function mapKey($key)
    {
        if (isset(self::$key_maps[$key])) {
            return self::$key_maps[$key];
        }
 
        return $key;
    }
 
 
    public static function getAllowedConnectorFields()
    {
        return self::$allowed_connector_fields;
    }
 
 
    public static function getAllowedDescriptionFields()
    {
        return self::$allowed_description_fields;
    }
 
 
 
    public static function getInstance(ActiveRecord $ar)
    {
        $arFieldList = new self($ar);
        $arFieldList->initRawFields($ar);
        $arFieldList->initFields();
 
        return $arFieldList;
    }
 
 
    public static function getInstanceFromStorage($ar)
    {
        $arFieldList = new self();
        $arFieldList->initRawFields($ar);
        $arFieldList->initFields();
 
        return $arFieldList;
    }
 
 
    public function getArrayForConnector()
    {
        $return = array();
        foreach ($this->getFields() as $field) {
            $return[$field->getName()] = $field->getAttributesForConnector();
        }
 
        return $return;
    }
 
 
    protected function initFields()
    {
        foreach ($this->getRawFields() as $fieldname => $attributes) {
            if (self::checkAttributes($attributes)) {
                $arField = new arField();
                $arField->getHasField(true);
                $arField->loadFromArray($fieldname, $attributes);
                $this->fields[] = $arField;
                if ($arField->getPrimary()) {
                    $this->setPrimaryField($arField);
                }
            }
        }
    }
 
 
    public function getFieldByName($field_name)
    {
        $field = null;
        static $field_map;
        $field_key = $this->ar->getConnectorContainerName() . '.' . $field_name;
        if ($field_map[$field_key]) {
            return $field_map[$field_key];
        }
        foreach ($this->getFields() as $field) {
            if ($field->getName() == $field_name) {
                $field_map[$field_key] = $field;
 
                return $field;
            }
        }
    }
 
 
    public function isField($field_name)
    {
        $is_field = false;
        foreach ($this->getFields() as $field) {
            if ($field->getName() == $field_name) {
                $is_field = true;
            }
        }
 
        return $is_field;
    }
 
 
    public function getPrimaryFieldName()
    {
        return $this->getPrimaryField()->getName();
    }
 
 
    public function getPrimaryFieldType()
    {
        return $this->getPrimaryField()->getFieldType();
    }
 
 
    protected function initRawFields(arStorageInterface $ar)
    {
        $regex = "/[ ]*\\* @(" . implode('|', self::$prefixes) . ")_([a-zA-Z0-9_]*)[ ]*([a-zA-Z0-9_]*)/u";
        $reflectionClass = new ReflectionClass($ar);
        $raw_fields = array();
        foreach ($reflectionClass->getProperties() as $property) {
            if (in_array($property->getName(), self::$protected_names)) {
                continue;
            }
            $properties_array = array();
            $has_property = false;
            foreach (explode("\n", $property->getDocComment()) as $line) {
                if (preg_match($regex, $line, $matches)) {
                    $has_property = true;
                    $properties_array[(string) $matches[2]] = $matches[3];
                }
            }
            if ($has_property) {
                $raw_fields[$property->getName()] = $properties_array;
            }
        }
 
        $this->setRawFields($raw_fields);
    }
 
 
    protected static function isAllowedAttribute($attribute_name)
    {
        return in_array($attribute_name, array_merge(self::$allowed_description_fields, array( self::HAS_FIELD )));
    }
 
 
    protected static function checkAttributes(array $attributes)
    {
        if (isset($attributes[self::HAS_FIELD]) && $attributes[self::HAS_FIELD] === 'true') {
            foreach (array_keys($attributes) as $atr) {
                if (!self::isAllowedAttribute($atr)) {
                    return false;
                }
            }
        } else {
            return false;
        }
 
        return true;
    }
 
 
    public function setFields($fields)
    {
        $this->fields = $fields;
    }
 
 
    public function getFields()
    {
        return $this->fields;
    }
 
 
    public function setPrimaryField($primary_field)
    {
        $this->primary_field = $primary_field;
    }
 
 
    public function getPrimaryField()
    {
        return $this->primary_field;
    }
 
 
    public function setRawFields($raw_fields)
    {
        $this->raw_fields = $raw_fields;
    }
 
 
    public function getRawFields()
    {
        return $this->raw_fields;
    }
 
 
    public function setPrimaryFields($primary_fields)
    {
        $this->primary_fields = $primary_fields;
    }
 
 
    public function getPrimaryFields()
    {
        return $this->primary_fields;
    }
}