Source for file FieldDescription.class.php

Documentation is available at FieldDescription.class.php

  1. /**
  2.  * Класс FieldDescription.
  3.  *
  4.  * @package energine
  5.  * @subpackage core
  6.  * @author dr.Pavka
  7.  * @copyright ColoCall 2006
  8.  * @version $Id: fsource_energine_core_frameworkFieldDescription.class.php.html,v 1.1 2007/09/17 14:32:33 pavka Exp $
  9.  */
  10.  
  11. require_once 'core/framework/DBWorker.class.php';
  12.  
  13. /**
  14.  * Описание поля данных.
  15.  *
  16.  * @package energine
  17.  * @subpackage core
  18.  */
  19. class FieldDescription extends DBWorker {
  20.     /**
  21.      * Имя поля для которого не указано имя :)
  22.      *
  23.      */
  24.     const EMPTY_FIELD_NAME = 'DUMMY';
  25.  
  26.     /*
  27.      * Визуальные типы полей:
  28.      */
  29.  
  30.     /**
  31.      * Строка
  32.      */
  33.     const FIELD_TYPE_STRING = 'string';
  34.  
  35.     /**
  36.      * Текст
  37.      */
  38.     const FIELD_TYPE_TEXT = 'text';
  39.  
  40.     /**
  41.      * Пароль
  42.      */
  43.     const FIELD_TYPE_PWD = 'password';
  44.  
  45.     /**
  46.      * E-mail
  47.      */
  48.     const FIELD_TYPE_EMAIL = 'email';
  49.  
  50.     /**
  51.      * Телефонный номер
  52.      */
  53.     const FIELD_TYPE_PHONE = 'phone';
  54.  
  55.     /**
  56.      * Целое число
  57.      */
  58.     const FIELD_TYPE_INT = 'integer';
  59.  
  60.     /**
  61.      * Число с плавающей точкой
  62.      */
  63.     const FIELD_TYPE_FLOAT = 'float';
  64.  
  65.     /**
  66.      * Изображение
  67.      */
  68.     const FIELD_TYPE_IMAGE = 'image';
  69.  
  70.     /**
  71.      * Файл
  72.      */
  73.     const FIELD_TYPE_FILE = 'file';
  74.  
  75.     /**
  76.      * Булево значение
  77.      */
  78.     const FIELD_TYPE_BOOL = 'boolean';
  79.  
  80.     /**
  81.      * HTML блок
  82.      */
  83.     const FIELD_TYPE_HTML_BLOCK = 'htmlblock';
  84.  
  85.     /**
  86.      * Единичный выбор из нескольких вариантов
  87.      */
  88.     const FIELD_TYPE_SELECT = 'select';
  89.  
  90.     /**
  91.      * Множественный выбор из нескольких вариантов
  92.      */
  93.     const FIELD_TYPE_MULTI = 'multi';
  94.  
  95.     /**
  96.      * Дата и время
  97.      */
  98.     const FIELD_TYPE_DATETIME = 'datetime';
  99.  
  100.     /**
  101.      * Дата
  102.      */
  103.     const FIELD_TYPE_DATE = 'date';
  104.  
  105.     /**
  106.      * Скрытое поле
  107.      */
  108.     const FIELD_TYPE_HIDDEN = 'hidden';
  109.  
  110.     /**
  111.      * Пользовательский тип поля (может содержать любые данные)
  112.      *
  113.      */
  114.     const FIELD_TYPE_CUSTOM = 'custom';
  115.  
  116.     /*
  117.      * Режимы отображения полей:
  118.      */
  119.  
  120.     /**
  121.      * Поле не отображается
  122.      */
  123.     const FIELD_MODE_NONE = 0;
  124.  
  125.     /**
  126.      * Только для чтения
  127.      */
  128.     const FIELD_MODE_READ = 1;
  129.  
  130.     /**
  131.      * Режим редактирования
  132.      */
  133.     const FIELD_MODE_EDIT = 2;
  134.  
  135.     /**
  136.      * Полный контроль
  137.      */
  138.     const FIELD_MODE_FC = 3;
  139.  
  140.     /**
  141.      * @access private
  142.      * @var array набор возможных значений (для полей типа select)
  143.      */
  144.     private $availableValues;
  145.  
  146.     /**
  147.      * @access private
  148.      * @var string имя поля
  149.      */
  150.     private $name;
  151.  
  152.     /**
  153.      * Для полей из БД, включает имя таблицы: tableName[name]
  154.      *
  155.      * @access private
  156.      * @var string системное имя поля
  157.      */
  158.     private $systemName;
  159.  
  160.     /**
  161.      * @access private
  162.      * @var string визуальный тип поля
  163.      */
  164.     private $type;
  165.  
  166.     /**
  167.      * @access private
  168.      * @var string тип поля в БД
  169.      */
  170.     private $systemType;
  171.  
  172.     /**
  173.      * @access private
  174.      * @var int режим отображения поля
  175.      */
  176.     private $mode = self::FIELD_MODE_EDIT;
  177.  
  178.     /**
  179.      * @access private
  180.      * @var int уровень прав на данное поле
  181.      */
  182.     private $rights;
  183.  
  184.     /**
  185.      * @access private
  186.      * @var boolean данные в поле мультиязычные?
  187.      */
  188.     private $isMultilanguage;
  189.  
  190.     /**
  191.      * Хэш вида array(propertyName => propertyValue).
  192.      *
  193.      * @access private
  194.      * @var Object дополнительные свойства поля
  195.      */
  196.     private $additionalProperties;
  197.  
  198.     /**
  199.      * Для полей не имеющих длины устанавливается в true.
  200.      *
  201.      * @access private
  202.      * @var int длина поля
  203.      */
  204.     private $length = true;
  205.  
  206.     /**
  207.      * Конструктор класса.
  208.      *
  209.      * @access public
  210.      * @param string $name имя поля
  211.      * @return void 
  212.      */
  213.     public function __construct($name self::EMPTY_FIELD_NAME{
  214.         parent::__construct();
  215.  
  216.         $this->name = $name;
  217.         $this->systemName = $name;
  218.         $this->isMultilanguage = false;
  219.         $this->additionalProperties = array();
  220.  
  221.         // формируем название поля добавляя префикс 'FIELD_'
  222.         if ($name!=self::EMPTY_FIELD_NAME {
  223.             $this->addProperty('title'$this->translate('FIELD_'.$name));
  224.         }
  225.  
  226.     }
  227.  
  228.     /**
  229.      * Загружает описание поля из массива.
  230.      *
  231.      * @access public
  232.      * @param array $fieldInfo 
  233.      * @return boolean 
  234.      */
  235.     public function loadArray(array $fieldInfo{
  236.         $result true;
  237.         foreach ($fieldInfo as $propName => $propValue{
  238.             switch ($propName{
  239.                 case 'type':
  240.                     $this->setSystemType($propValue);
  241.                     break;
  242.                 case 'length':
  243.                     $this->setLength($propValue);
  244.                     break;
  245.                 case 'isMultilanguage':
  246.                     $this->isMultilanguage = true;
  247.                     break;
  248.                 default:
  249.                     $this->addProperty($propName$propValue);
  250.             }
  251.         }
  252.         return $result;
  253.     }
  254.  
  255.     /**
  256.      * Загружает описание поля из XML-описания.
  257.      *
  258.      * @access public
  259.      * @param SimpleXMLElement $fieldInfo 
  260.      * @return boolean 
  261.      */
  262.     public function loadXML(SimpleXMLElement $fieldInfo{
  263.         $result true;
  264.         foreach ($fieldInfo->attributes(as $attrName => $attrValue{
  265.             $attrName = (string)$attrName;
  266.             $attrValue = (string)$attrValue;
  267.             switch ($attrName{
  268.                 case 'name':
  269.                     $this->name $attrValue;
  270.                     break;
  271.                 case 'type':
  272.                     $this->setSystemType($attrValue);
  273.                     break;
  274.                 case 'length':
  275.                     $this->setLength($attrValue);
  276.                     break;
  277.                 case 'mode':
  278.                     $this->setMode($attrValue);
  279.                     break;
  280.                 default:
  281.                     if ($attrName == 'title'{
  282.                         $attrValue $this->translate($attrValue);
  283.                     }
  284.                     elseif ($attrName == 'message'{
  285.                         $attrValue $this->translate($attrValue);
  286.                     }
  287.                     $this->addProperty($attrName$attrValue);
  288.             }
  289.         }
  290.         return $result;
  291.     }
  292.  
  293.     /**
  294.      * Возвращает имя поля.
  295.      *
  296.      * @access public
  297.      * @return string 
  298.      */
  299.     public function getName({
  300.         return $this->name;
  301.     }
  302.  
  303.     /**
  304.      * Устанавливает системное имя поля.
  305.      *
  306.      * @access public
  307.      * @param string $systemName 
  308.      * @return void 
  309.      */
  310.     public function setSystemName($systemName{
  311.         $this->systemName $systemName;
  312.     }
  313.  
  314.     /**
  315.      * Возвращает длину поля.
  316.      *
  317.      * @access public
  318.      * @return int | true
  319.      */
  320.     public function getLength({
  321.         return $this->length;
  322.     }
  323.  
  324.     /**
  325.      * Устанавливает длину поля.
  326.      *
  327.      * @access public
  328.      * @param int $length 
  329.      * @return void 
  330.      */
  331.     public function setLength($length{
  332.         $this->length = (int)$length;
  333.     }
  334.  
  335.     /**
  336.      * Возвращает системное имя поля.
  337.      *
  338.      * @access public
  339.      * @return string 
  340.      */
  341.     public function getSystemName({
  342.         return $this->systemName;
  343.     }
  344.  
  345.     /**
  346.      * Устанавливает визуальный тип поля.
  347.      *
  348.      * @access public
  349.      * @param string $type 
  350.      * @return void 
  351.      */
  352.     public function setType($type{
  353.         $this->type = (string)$type;
  354.         switch ($this->type{
  355.             case self::FIELD_TYPE_PWD :
  356.                         $this->addProperty('pattern''/^.+$/');
  357.                         $this->addProperty('message'$this->translate('MSG_FIELD_IS_NOT_NULL'));
  358.                         $this->addProperty('outputFormat''%s');
  359.                  break;
  360.             case self::FIELD_TYPE_EMAIL:
  361.                     if ($this->getPropertyValue('nullable'=== false{
  362.                         $regexp '/^(([^()<>@,;:\\\".\[\] ]+)|("[^"\\\\\r]*"))((\.[^()<>@,;:\\\".\[\] ]+)|(\."[^"\\\\\r]*"))*@(([a-z0-9][a-z0-9\-]+)*[a-z0-9]+\.)+[a-z]{2,}$/i';
  363.                     }
  364.                     else {
  365.                         $regexp '/^((([^()<>@,;:\\\".\[\] ]+)|("[^"\\\\\r]*"))((\.[^()<>@,;:\\\".\[\] ]+)|(\."[^"\\\\\r]*"))*@(([a-z0-9][a-z0-9\-]+)*[a-z0-9]+\.)+[a-z]{2,})?$/i';
  366.                     }
  367.                     $this->addProperty('pattern'$regexp);
  368.                     $this->addProperty('message'$this->translate('MSG_BAD_EMAIL_FORMAT'));
  369.                     $this->addProperty('outputFormat''%s');
  370.                 break;
  371.                 case  self::FIELD_TYPE_PHONE:
  372.                     if ($this->getPropertyValue('nullable'=== false{
  373.                         $regexp '/^[0-9\(\)\+\-\. ]{5,25}$/';
  374.                     }
  375.                     else {
  376.                         $regexp '/^([0-9\(\)\+\-\. ]{5,25})?$/';
  377.                     }
  378.                     $this->addProperty('pattern'$regexp);
  379.                     $this->addProperty('message'$this->translate('MSG_BAD_PHONE_FORMAT'));
  380.                     $this->addProperty('outputFormat''%s');
  381.                 break;
  382.                 case self::FIELD_TYPE_IMAGE:
  383.                     if ($this->getPropertyValue('nullable'=== false{
  384.                         $this->addProperty('pattern''/^.+$/');
  385.                         $this->addProperty('message'$this->translate('MSG_IMG_IS_NOT_NULL'));
  386.                     }
  387.                     $this->length true;
  388.                     $this->addProperty('outputFormat''%s');
  389.                 break;
  390.                 case self::FIELD_TYPE_FILE:
  391.                     if ($this->getPropertyValue('nullable'=== false{
  392.                         $this->addProperty('pattern''/^.+$/');
  393.                         $this->addProperty('message'$this->translate('MSG_FILE_IS_NOT_NULL'));
  394.                     }
  395.                     $this->length true;
  396.                     $this->addProperty('outputFormat''%s');
  397.                 break;
  398.                 case self::FIELD_TYPE_STRING:
  399.                     if ($this->getPropertyValue('nullable'=== false{
  400.                         $this->addProperty('pattern''/^.+$/');
  401.                         $this->addProperty('message'$this->translate('MSG_FIELD_IS_NOT_NULL'));
  402.                     }
  403.                     $this->addProperty('outputFormat''%s');
  404.                 break;
  405.                 case self::FIELD_TYPE_FLOAT:
  406.                     $this->length 10;
  407.                     if ($this->getPropertyValue('nullable'=== false{
  408.                         $regexp '/^[0-9\.]{1,'.$this->length.'}$/';
  409.                     }
  410.                     else {
  411.                         $regexp '/^[0-9\.]{0,'.$this->length.'}$/';
  412.                     }
  413.                     $this->addProperty('outputFormat''%f');
  414.                     $this->addProperty('pattern'$regexp);
  415.                     $this->addProperty('message'$this->translate('MSG_BAD_FLOAT_FORMAT'));
  416.                 break;
  417.                 case self::FIELD_TYPE_BOOL:
  418.                     $this->length true;
  419.                     $this->addProperty('outputFormat''%s');
  420.                 break;
  421.                 case self::FIELD_TYPE_SELECT:
  422.                     $this->length true;
  423.                 break;
  424.                 case self::FIELD_TYPE_INT:
  425.                     if (!$this->getPropertyValue('key')) {
  426.                         if ($this->getPropertyValue('nullable'=== false{
  427.                             $regexp '/^\d{1,3}$/';
  428.                             $message $this->translate('MSG_BAD_INT_FORMAT_OR_NULL');
  429.                         }
  430.                         else {
  431.                             $regexp '/^\d{0,3}$/';
  432.                             $message $this->translate('MSG_BAD_INT_FORMAT');
  433.                         }
  434.                         $this->addProperty('pattern'$regexp);
  435.                         $this->addProperty('message'$message);
  436.                         $this->addProperty('outputFormat''%d');
  437.                     }
  438.                 break;
  439.                 case self::FIELD_TYPE_TEXT:
  440.                 case self::FIELD_TYPE_HTML_BLOCK:
  441.                     if ($this->getPropertyValue('nullable'=== false{
  442.                         $this->addProperty('pattern''/^.+$/m');
  443.                         $this->addProperty('message'$this->translate('MSG_FIELD_IS_NOT_NULL'));
  444.                     }
  445.                     $this->addProperty('outputFormat''%s');
  446.                     $this->length true;
  447.                 break;
  448.                 case self::FIELD_TYPE_DATETIME:
  449.                     if ($this->getPropertyValue('nullable'=== false{
  450.                         $regexp '/^\d{4}\-\d{1,2}\-\d{1,2} \d{1,2}:\d{1,2}:\d{1,2}$/';
  451.                     }
  452.                     else {
  453.                         $regexp '/^(\d{4}\-\d{1,2}\-\d{1,2} \d{1,2}:\d{1,2}:\d{1,2})?$/';
  454.                     }
  455.                     $this->addProperty('pattern'$regexp);
  456.                     $this->addProperty('outputFormat''%Y-%m-%d %H:%M:%S');
  457.                     $this->addProperty('message'$this->translate('MSG_WRONG_DATETIME_FORMAT'));
  458.                     $this->length true;
  459.                 break;
  460.                 case self::FIELD_TYPE_DATE:
  461.                     if ($this->getPropertyValue('nullable'=== false{
  462.                         $regexp '/^\d{4}\-\d{1,2}\-\d{1,2}$/';
  463.                     }
  464.                     else {
  465.                         $regexp '/^(\d{4}\-\d{1,2}\-\d{1,2})?$/';
  466.                     }
  467.                     $this->addProperty('pattern'$regexp);
  468.                     $this->addProperty('outputFormat''%Y-%m-%d');
  469.                     $this->addProperty('message'$this->translate('MSG_WRONG_DATE_FORMAT'));
  470.                     $this->length true;
  471.                 break;
  472.             default:
  473.                 break;
  474.         }
  475.     }
  476.  
  477.     /**
  478.      * Возвращает визуальный тип поля.
  479.      *
  480.      * @access public
  481.      * @return string 
  482.      */
  483.     public function getType({
  484.         return $this->type;
  485.     }
  486.  
  487.     /**
  488.      * Устанавливает системный тип поля, одновременно устанавливая на
  489.      * основании его визуальный тип.
  490.      *
  491.      * @access public
  492.      * @param string $systemType 
  493.      * @return void 
  494.      */
  495.     public function setSystemType($systemType{
  496.         $this->systemType $systemType;
  497.         $this->setType($this->convertType($systemType));
  498.     }
  499.  
  500.     /**
  501.      * Возвращает системный тип поля.
  502.      *
  503.      * @access public
  504.      * @return string 
  505.      */
  506.     public function getSystemType({
  507.         return $this->systemType;
  508.     }
  509.  
  510.     /**
  511.      * Устанавливает режим отображения поля.
  512.      *
  513.      * @access public
  514.      * @param int $mode 
  515.      * @return void 
  516.      */
  517.     public function setMode($mode{
  518.         $this->mode $mode;
  519.     }
  520.  
  521.     /**
  522.      * Возвращает режим отображения поля.
  523.      *
  524.      * @access public
  525.      * @return int 
  526.      */
  527.     public function getMode({
  528.         return $this->mode;
  529.     }
  530.  
  531.     /**
  532.      * Устанавливает уровень прав на поле.
  533.      *
  534.      * @access public
  535.      * @param int $rights 
  536.      * @return void 
  537.      */
  538.     public function setRights($rights{
  539.         $this->rights $rights;
  540.     }
  541.  
  542.     /**
  543.      * Возвращает уровень прав на поле.
  544.      *
  545.      * @access public
  546.      * @return int 
  547.      */
  548.     public function getRights({
  549.         return $this->rights;
  550.     }
  551.  
  552.     /**
  553.      * Добавляет свойство поля.
  554.      *
  555.      * @access public
  556.      * @param string $name 
  557.      * @param mixed $value 
  558.      * @return void 
  559.      */
  560.     public function addProperty($name$value{
  561.         if ($name == 'nullable'{
  562.             $value = (bool)$value;
  563.         }
  564.         $this->additionalProperties[$name$value;
  565.     }
  566.  
  567.     /**
  568.      * Удаляет свойство поля.
  569.      *
  570.      * @access public
  571.      * @param string $name 
  572.      * @return void 
  573.      */
  574.     public function removeProperty($name{
  575.         unset($this->additionalProperties[$name]);
  576.     }
  577.  
  578.     /**
  579.      * Возвращает список имен дополнительных свойств поля.
  580.      *
  581.      * @access public
  582.      * @return array 
  583.      */
  584.     public function getPropertyNames({
  585.         return array_keys($this->additionalProperties);
  586.     }
  587.  
  588.     /**
  589.      * Возвращает значение свойства поля.
  590.      *
  591.      * @access public
  592.      * @param string $name 
  593.      * @return mixed 
  594.      */
  595.     public function getPropertyValue($name{
  596.         $value null;
  597.         if (isset($this->additionalProperties[$name])) {
  598.             $value $this->additionalProperties[$name];
  599.         }
  600.         return $value;
  601.     }
  602.  
  603.     /**
  604.      * Конвертирует тип поля из системного типа в визуальный.
  605.      *
  606.      * @access protected
  607.      * @param string $systemType 
  608.      * @return string 
  609.      */
  610.     protected function convertType($systemType{
  611.         switch ($systemType{
  612.             case DBA::COLTYPE_STRING:
  613.                 if (strpos($this->name'_password')) {
  614.                     $result self::FIELD_TYPE_PWD;
  615.                 }
  616.                 elseif (strpos($this->name'_email')) {
  617.                     $result self::FIELD_TYPE_EMAIL;
  618.                 }
  619.                 elseif (strpos($this->name'_phone')) {
  620.                     $result self::FIELD_TYPE_PHONE;
  621.                 }
  622.                 elseif (strpos($this->name'_img')) {
  623.                     $result self::FIELD_TYPE_IMAGE;
  624.                 }
  625.                 elseif (strpos($this->name'_file')) {
  626.                     $result self::FIELD_TYPE_FILE;
  627.                 }
  628.                 else {
  629.                     $result self::FIELD_TYPE_STRING;
  630.                 }
  631.                 break;
  632.             case DBA::COLTYPE_FLOAT:
  633.                 $result self::FIELD_TYPE_FLOAT;
  634.                 break;
  635.             case DBA::COLTYPE_INTEGER:
  636.                 if ($this->length == 1{
  637.                     $result self::FIELD_TYPE_BOOL;
  638.                 }
  639.                 // обрабатываем внешний ключ
  640.                 elseif (is_array($this->getPropertyValue('key'))) {
  641.                     $result self::FIELD_TYPE_SELECT;
  642.                 }
  643.                 else {
  644.                     $result self::FIELD_TYPE_INT;
  645.                 }
  646.                 break;
  647.             case DBA::COLTYPE_TEXT:
  648.                 if (strpos($this->name'_rtf')) {
  649.                     $result self::FIELD_TYPE_HTML_BLOCK;
  650.                 }
  651.                 else {
  652.                     $result self::FIELD_TYPE_TEXT;
  653.                 }
  654.                 break;
  655.             case DBA::COLTYPE_DATETIME:
  656.                 $result self::FIELD_TYPE_DATETIME;
  657.                 break;
  658.             case DBA::COLTYPE_DATE:
  659.                 $result self::FIELD_TYPE_DATE;
  660.                 break;
  661.             default:
  662.                 $result $systemType;
  663.         }
  664.         return $result;
  665.     }
  666.  
  667.     /**
  668.      * Пересечение мета-данных конфигурации и мета-данных, полученных из БД.
  669.      *
  670.      * @access public
  671.      * @param FieldDescription основное описание
  672.      * @param FieldDescription дополнительное описание
  673.      *
  674.      * @return FieldDescription 
  675.      * @static
  676.      */
  677.     public static function intersect(FieldDescription $primaryFieldDescriptionFieldDescription $secondaryFieldDescription{
  678.         $type $primaryFieldDescription->getType();
  679.         $mode $primaryFieldDescription->getMode();
  680.  
  681.         if (!is_null($type)) {
  682.             //меняем тип
  683.             $secondaryFieldDescription->setType($type);
  684.         }
  685.         if (!is_null($mode)) {
  686.             $secondaryFieldDescription->setMode($mode);
  687.         }
  688.         $secondaryFieldDescription->isMultilanguage = $primaryFieldDescription->isMultilanguage || $secondaryFieldDescription->isMultilanguage();
  689.         $properties $secondaryFieldDescription->getPropertyNames();
  690.         foreach ($properties as $propertyName{
  691.             $propertyValue $primaryFieldDescription->getPropertyValue($propertyName);
  692.  
  693.             if (!is_null($propertyValue&& !($propertyName == 'title' && $propertyValue == 'FIELD_'.self::EMPTY_FIELD_NAME)) {
  694.                 if ($propertyName == 'message'{
  695.                     $propertyValue $primaryFieldDescription->translate($propertyValue);
  696.                 }
  697.  
  698.                 $secondaryFieldDescription->addProperty($propertyName$propertyValue);
  699.             }
  700.         }
  701.  
  702.         return $secondaryFieldDescription;
  703.     }
  704.  
  705.     /**
  706.      * Проверяет корректность переданных данных.
  707.      *
  708.      * @access public
  709.      * @param mixed $data 
  710.      * @return boolean 
  711.      */
  712.     public function validate($data{
  713.         if (is_int($this->length&& strlen($data$this->length{
  714.             return false;
  715.         }
  716.         if ($this->getPropertyValue('pattern'&& !preg_match($this->getPropertyValue('pattern')$data)) {
  717.             return false;
  718.         }
  719.         return true;
  720.     }
  721.  
  722.     /**
  723.      * Возвращает флаг мультиязычности данных.
  724.      *
  725.      * @access public
  726.      * @return boolean 
  727.      */
  728.     public function isMultilanguage({
  729.         return $this->isMultilanguage;
  730.     }
  731.  
  732.     /**
  733.      * Загружает набор возможных значений поля.
  734.      *
  735.      * @access public
  736.      * @param mixed $values набор значений
  737.      * @param string $keyName имя поля-ключа
  738.      * @param string $valueName имя поля основного значения
  739.      * @return void 
  740.      * @see QAL::select()
  741.      */
  742.     public function loadAvailableValues($values$keyName$valueName{
  743.         $result array();
  744.         if (is_array($values)) {
  745.             foreach ($values as $row{
  746.                 $key $row[$keyName];
  747.                 $value $row[$valueName];
  748.  
  749.                 unset($row[$keyName]);
  750.                 unset($row[$valueName]);
  751.  
  752.                 $result[$keyarray(
  753.                     'value' => $value,
  754.                     'attributes' => (empty($rowfalse $row)
  755.                 );
  756.             }
  757.         }
  758.         $this->availableValues $result;
  759.     }
  760.  
  761.     /**
  762.      * Возвращает набор возможных значений поля.
  763.      *
  764.      * @access public
  765.      * @return array 
  766.      */
  767.     public function getAvailableValues({
  768.         return $this->availableValues;
  769.     }
  770.  
  771.     /**
  772.      * Определяет значение режима отображения элемента
  773.      *
  774.      * @return int 
  775.      * @access public
  776.      * @static
  777.      */
  778.  
  779.     public static function computeRights($methodRights$RORights null$FCRights null{
  780.         //Если уровень прав не указан, берем права документа
  781.         $RORights = is_null($RORights)?$methodRights:$RORights;
  782.         $FCRights = is_null($FCRights)?$methodRights:$FCRights;
  783.  
  784.  
  785.         //Если права на чтение на контрол меньше чем права на метод, то контрол - невидим
  786.         if($methodRights<$RORights{
  787.             $result FieldDescription::FIELD_MODE_NONE;
  788.         }
  789.         //Если права на чтение на контрол больше или равны правам на метод, и права на запись меньше  - просто выводится текст контрола
  790.         elseif($methodRights >= $RORights&&$methodRights<$FCRights)
  791.         {
  792.             $result FieldDescription::FIELD_MODE_READ;
  793.         }
  794.         elseif($methodRights>=$FCRights)
  795.         {
  796.             $result FieldDescription::FIELD_MODE_EDIT;
  797.         }
  798.  
  799.         Return $result;
  800.     }
  801.  
  802. }

Documentation generated on Mon, 17 Sep 2007 13:28:48 +0300 by phpDocumentor 1.4.0a2