Source for file TableFilters.php

Documentation is available at TableFilters.php

  1. <?php
  2.     /**
  3.      * User Interface Util Class
  4.      *
  5.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  6.      * @package MIPHPF
  7.      */
  8.  
  9.     /**
  10.      * Filters support class
  11.      * 
  12.      * @copyright Copyright (c) 2006 Mirchev Ideas Ltd. All rights reserved.
  13.      * @package MIPHPF
  14.      */
  15.     class miTableFilters extends miTableFeature {
  16.         const FILTER_NAME_SUFFIX = 'Filter';
  17.         const FILTER_CONDITION_SUFFIX = 'Condition';
  18.         
  19.         /**
  20.          * An associative array with filter field and value
  21.          * 
  22.          * @access protected
  23.          * @var array 
  24.          */
  25.         protected $_defaultFilterValues = array();
  26.         
  27.         
  28.         /**
  29.          * Additional filters added by application logic
  30.          * 
  31.          * @access protected
  32.          * @var array 
  33.          */
  34.         protected $_additionalFilters = array();
  35.         
  36.         
  37.         /**
  38.          * Map between the filter conditions and the actual filter class
  39.          * 
  40.          * @access protected
  41.          * @var array 
  42.          */
  43.         protected $_conditionMap = array(
  44.             '=' => 'miSqlFilterEqual',
  45.             '!=' => 'miSqlFilterNotEqual',
  46.             '>' => 'miSqlFilterBiggerThan',
  47.             '>=' => 'miSqlFilterBiggerOrEqual',
  48.             '<' => 'miSqlFilterSmallerThan',
  49.             '<=' => 'miSqlFilterSmallerOrEqual',
  50.             'substring' => 'miSqlFilterSubstring',
  51.             'starts' => 'miSqlFilterStarts',
  52.             'ends' => 'miSqlFilterEnds',
  53.             'regexp' => 'miSqlFilterRegExp',
  54.             'in' => 'miSqlFilterIn',
  55.             'notin' => 'miSqlFilterNotIn',
  56.         );
  57.             
  58.         
  59.         /**
  60.          * Sets a condition handler
  61.          * The miView expects the handler class be subclassed from miSqlFilter
  62.          * 
  63.          * @access public
  64.          * @param string $condition 
  65.          * @param string $handlerClassName 
  66.          */
  67.         public function setConditionHandler($condition, $handlerClassName)
  68.         {
  69.             $this->_conditionMap[$condition] = $handlerClassName;
  70.         }
  71.         
  72.         /**
  73.          * Set the default filter values
  74.          * 
  75.          * @param array $defaultFilterValues an associative array with filter field and value
  76.          */
  77.         public function setDefaultFilterValues($defaultFilterValues)
  78.         {
  79.             $this->_defaultFilterValues = $defaultFilterValues;
  80.         }
  81.         
  82.         
  83.         /**
  84.          * Adds an additional filter
  85.          * 
  86.          * @param string $field 
  87.          * @param string $value 
  88.          * @param string $condition 
  89.          */
  90.         public function addAdditionalFilter($field, $value, $condition)
  91.         {
  92.             $this->_additionalFilters[] = array($field, $value, $condition);
  93.         }
  94.         
  95.         
  96.         /**
  97.          * The the current filters values
  98.          * 
  99.          * @return array associative array with each filter and it's value
  100.          * @throws miConfigurationException
  101.          */
  102.         public function getFilterValues()
  103.         {
  104.             $filters = $this->getFiltersFromRequest();
  105.             
  106.             $filterValues = $this->_defaultFilterValues;
  107.             foreach ($filters as $filter) {
  108.                 $filterValues[$filter[0]] = $filter[1];
  109.             }
  110.             return $filterValues;
  111.         }
  112.         
  113.         /**
  114.          * Returns the filter value of $filterName
  115.          * The request is checked first, then the default filter values,
  116.          * and if the $filterName cannot not found returns empty string
  117.          * 
  118.          * TODO: improve efficiency by not using getFilterValues()
  119.          * 
  120.          * @access public
  121.          * @param string $filterName 
  122.          * @return string the filter value
  123.          */
  124.         public function getFilterValue($filterName)
  125.         {
  126.             $filters = $this->getFilterValues();
  127.             
  128.             if (isset($filters[$filterName]))
  129.                 return $filters[$filterName];
  130.             
  131.             if (isset($this->_defaultFilterValues[$filterName]))
  132.                 return $this->_defaultFilterValues[$filterName];
  133.             
  134.             return '';
  135.         }
  136.         
  137.         /**
  138.          * Get the feature values
  139.          * 
  140.          * @access public
  141.          * @return array 
  142.          * @throws miConfigurationException
  143.          */
  144.         public function getValues()
  145.         {
  146.             $filterValues = $this->getFilterValues();
  147.             $values = array();
  148.             foreach ($filterValues as $field => $filter) {
  149.                 if (!is_array($filter)) {
  150.                     $values[strtoupper($field) . '_FILTERVALUE'] = $filter;
  151.                     continue;
  152.                 }
  153.                 foreach ($filter as $key => $value) {
  154.                     $values[strtoupper($field) . '_FILTERVALUE[' . $key . ']'] = $value;
  155.                 }
  156.             }
  157.             $values['FILTER_PARAMS'] = $this->_table->paramsArrayToUrl($this->getStateParams());
  158.             return $values;
  159.         }
  160.         
  161.         /**
  162.          * Returns associative array with params that save the feature state
  163.          * 
  164.          * @return array 
  165.          * @throws miConfigurationException
  166.          */
  167.         public function getStateParams()
  168.         {
  169.             $filterArray = $this->getFiltersFromRequest();
  170.             $params = array();
  171.             foreach ($filterArray as $filter) {
  172.                 if (!is_array($filter[1])) {
  173.                     $params[$filter[0] . self::FILTER_NAME_SUFFIX] = $filter[1];
  174.                     $params[$filter[0] . self::FILTER_CONDITION_SUFFIX] = $filter[2];
  175.                     continue;
  176.                 }
  177.                 foreach ($filter[1] as $key => $value) {
  178.                     $params[$filter[0] . self::FILTER_NAME_SUFFIX . '[' . $key . ']'] = $value;
  179.                     $params[$filter[0] . self::FILTER_CONDITION_SUFFIX . '[' . $key . ']'] = $filter[2][$key];
  180.                 }
  181.             }
  182.             return $params;
  183.         }
  184.         
  185.         /**
  186.          * Gets all filter parameters from the request
  187.          * Returns the additional filters along with the filters from the request
  188.          * Uses $_REQUEST superglobal instead of $_GET or $_POST
  189.          * Note: Value and Condition can be arrays
  190.          * 
  191.          * @access public
  192.          * @return array array of arrays that each holding the field name[0], value[1] and condition[2]
  193.          * @throws miConfigurationException
  194.          */ 
  195.         public function getFiltersFromRequest()
  196.         {
  197.             $filters = array();
  198.             $suffixLen = strlen(self::FILTER_NAME_SUFFIX);
  199.             $state = $this->_table->getState();
  200.             foreach ($state as $property => $value) {
  201.                 if (substr_compare($property, self::FILTER_NAME_SUFFIX, -$suffixLen))
  202.                     continue;
  203.                 
  204.                 $field = substr($property, 0, -$suffixLen);
  205.                 $condition = isset($state[$field . self::FILTER_CONDITION_SUFFIX]) ? $state[$field . self::FILTER_CONDITION_SUFFIX] : '=';
  206.                 
  207.                 if (is_array($value) and is_array($condition)) {
  208.                     if (count($value) != count($condition))
  209.                         throw new miConfigurationException('Filter values and filter conditions arrays must be same size:' . $field, miConfigurationException::EXCEPTION_FILTER_SAME_ARRAY_SIZE);
  210.                     
  211.                     // For security purposes only numeric indexes are allowed
  212.                     $filters[] = array($field, array_values($value), array_values($condition));
  213.                     continue;
  214.                 }
  215.                 
  216.                 if (is_array($value) or is_array($condition))
  217.                     throw new miConfigurationException('Filter values and filter conditions must be either both array or both non-array inputs: ' . $field, miConfigurationException::EXCEPTION_FILTER_ONE_IS_ARRAY);
  218.                 
  219.                 $filters[] = array($field, $value, $condition);
  220.             }
  221.             
  222.             return $filters + $this->_additionalFilters;
  223.         }
  224.         
  225.         
  226.         /**
  227.          * Returns an array of filter objects
  228.          * 
  229.          * @return array array of objects, subclasses of miSqlFilter
  230.          * @throws miConfigurationException
  231.          */
  232.         public function getFilterObjs()
  233.         {
  234.             $filterObjs = array();
  235.             
  236.             $filters = $this->getFiltersFromRequest();
  237.             foreach ($filters as $filter) {
  238.                 if (!is_array($filter[1])) {
  239.                     $filterObjs[] = $this->createFilterObj($filter[0], $filter[1], $filter[2]);
  240.                     continue;
  241.                 }
  242.                 foreach ($filter[1] as $key => $value)
  243.                     $filterObjs[] = $this->createFilterObj($filter[0], $value, $filter[2][$key]);
  244.             }
  245.             return $filterObjs;
  246.         }
  247.         
  248.         
  249.         /**
  250.          * Creates a filter object
  251.          * The object depends on the $condition
  252.          * 
  253.          * @param string $field the filter field
  254.          * @param string $value 
  255.          * @param string $condition 
  256.          * @throws miConfigurationException
  257.          */
  258.         protected function createFilterObj($field, $value, $condition)
  259.         {
  260.             if (empty($this->_conditionMap[$condition]))
  261.                 throw new miConfigurationException('Invalid filter condition ' . $condition . ' for ' . $field, miConfigurationException::EXCEPTION_FILTER_CONDITION);
  262.             
  263.             return new $this->_conditionMap[$condition]($field, $value);
  264.         }
  265.     }
  266. ?>

Documentation generated on Thu, 08 May 2008 16:57:45 +0300 by phpDocumentor 1.4.1