<?php
/*******************************************************************************
 * Copyright (C) 2007 Easter-eggs
 * https://ldapsaisie.org
 *
 * Author: See AUTHORS file in top-level directory.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

******************************************************************************/

LSsession :: loadLSclass('LSlog_staticLoggerClass');

/**
 * Object LSsearch
 *
 * @author Benjamin Renard <brenard@easter-eggs.com>
 */
class LSsearch extends LSlog_staticLoggerClass {

  // The LdapObject type of search
  private $LSobject=NULL;

  // The configuration of search
  private $config;

  // The context of search
  private $context;

  // The parameters of the search
  private $params=array (
    // Search params
    'filter' => NULL,
    'pattern' => NULL,
    'predefinedFilter' => false,
    'basedn' => NULL,
    'subDn' => NULL,
    'scope' => NULL,
    'sizelimit' => 0,
    'attronly' => false,    // If true, only attribute names are returned
    'approx' => false,
    'recursive' => false,
    'attributes' => array(),
    // Display params
    'onlyAccessible' => NULL,
    'sortDirection' => NULL,
    'sortBy' => NULL,
    'sortlimit' => 0,
    'displaySubDn' => NULL,
    'displayFormat' => NULL,
    'nbObjectsByPage' => NB_LSOBJECT_LIST,
    'nbObjectsByPageChoices' => NULL,
    'customInfos' => array(),
    'withoutCache' => false,
    'extraDisplayedColumns' => false,
  );

  // The cache of search parameters
  private $_searchParams = NULL;

  // The result of the search
  private $result=NULL;

  // Caches
  private $_canCopy=NULL;

  /**
   * Constructor
   *
   * @param[in] $LSobject string The LdapObject type of search
   * @param[in] $context string Context of search (LSrelation / LSldapObject/ ...)
   * @param[in] $params array Parameters of search
   * @param[in] $purgeParams boolean If params in session have to be purged
   *
   **/
  public function __construct($LSobject,$context,$params=null,$purgeParams=false) {
    if (!LSsession :: loadLSobject($LSobject)) {
      return;
    }
    $this -> LSobject = $LSobject;

    $this -> loadConfig();

    if (isset($_REQUEST['LSsearchPurgeSession'])) {
      $this -> purgeSession();
    }

    $this -> context = $context;

    if (!$purgeParams) {
      if (! $this -> loadParamsFromSession()) {
        $this -> loadDefaultParameters();
      }
    }
    else {
      $this -> purgeParams($LSobject);
      $this -> loadDefaultParameters();
    }

    if (is_array($params)) {
      $this -> setParams($params);
    }

  }

  /**
   * Allow conversion of LSsearch to string
   *
   * @retval string The string representation of the LSsearch
   */
  public function __toString() {
    $search_params = $this -> formatSearchParams();
    return "<LSsearch of ".$this -> LSobject." (context=".$this -> context.")".($search_params?" $search_params":"").">";
  }

  /**
   * Load configuration from LSconfig
   *
   * @retval void
   */
  private function loadConfig() {
    $this -> config = LSconfig::get("LSobjects.".$this -> LSobject.".LSsearch");
    if (isset($this -> config['predefinedFilters']) && is_array($this -> config['predefinedFilters'])) {
      foreach($this -> config['predefinedFilters'] as $filter => $label) {
        if(!LSldap::isValidFilter($filter)) {
          LSerror::addErrorCode('LSsearch_15',array('label' => $label, 'filter' => $filter, 'type' => $this -> LSobject));
          unset($this -> config['predefinedFilters'][$filter]);
        }
      }
    }
  }

  /**
   * Load default search parameters from configuration
   *
   * @retval boolean True on success or False
   */
  private function loadDefaultParameters() {
    if (isset($this -> config['params']) && is_array($this -> config['params'])) {
      self :: log_debug('Load default parameters (from object type configuration)');
      return $this -> setParams($this -> config['params']);
    }
    else
      self :: log_trace('loadDefaultParameters(): no parameters found in object type configuration');
    return true;
  }

  /**
   * Load search parameters from session
   *
   * @retval boolean True if params has been loaded from session or False
   */
  private function loadParamsFromSession() {
    if (isset($_SESSION['LSsession']['LSsearch'][$this -> LSobject]['params'][$this -> context]) && is_array($_SESSION['LSsession']['LSsearch'][$this -> LSobject]['params'][$this -> context])) {
      self :: log_debug('Load params from session for context '.$this -> context);
      $params = $_SESSION['LSsession']['LSsearch'][$this -> LSobject]['params'][$this -> context];

      if ($params['filter']) {
        $params['filter'] = Net_LDAP2_Filter::parse($params['filter']);
      }

      $this -> params = $params;
      return true;
    }
    else
      self :: log_trace("loadParamsFromSession(): no params in session for context ".$this -> context);
    return;
  }

  /**
   * Save search parameters in session
   *
   * @retval void
   */
  private function saveParamsInSession() {
    self :: log_debug('Save context params session '.$this -> context);
    $params = $this -> params;
    if ($params['filter'] instanceof Net_LDAP2_Filter) {
      $params['filter'] = $params['filter'] -> asString();
    }

    foreach ($params as $param => $value) {
      if ( !isset($_SESSION['LSsession']['LSsearch'][$this -> LSobject]['params'][$this -> context][$param]) || $_SESSION['LSsession']['LSsearch'][$this -> LSobject]['params'][$this -> context][$param]!=$value) {
        self :: log_trace("$param => ".varDump($value));
        $_SESSION['LSsession']['LSsearch'][$this -> LSobject]['params'][$this -> context][$param]=$value;
      }
    }
  }

  /**
   * Purge parameters in session
   *
   * @param[in] $LSobject string The LSobject type
   *
   * @retval void
   */
  public static function purgeParams($LSobject) {
    unset($_SESSION['LSsession']['LSsearch'][$LSobject]['params']);
  }

  /**
   * Purge cache
   *
   * @retval void
   */
  public static function purgeCache($LSobject) {
    unset($_SESSION['LSsession']['LSsearch'][$LSobject]);
  }

  /**
   * Purge session
   *
   * @retval void
   */
  private function purgeSession() {
    unset($_SESSION['LSsession']['LSsearch']);
  }

  /**
   * Define one search parameter
   *
   * @param[in] $param string The parameter name
   * @param[in] $value mixed The parameter value
   *
   * @retval boolean True on success or False
   */
  public function setParam($param,$value) {
    return $this -> setParams(array($param => $value));
  }

  /**
   * Define search parameters
   *
   * @param[in] $params array Parameters of search
   *
   * @retval boolean True on success or False
   */
  public function setParams($params) {
    $OK=true;

    // Filter
    if (isset($params['filter'])) {
      if (is_string($params['filter'])) {
        $filter = Net_LDAP2_Filter::parse($params['filter']);
        if (!LSerror::isLdapError($filter)) {
          $this -> params['filter'] = $filter;
        }
        else {
          LSerror :: addErrorCode('LSsearch_01',$params['filter']);
          $OK=false;
        }
      }
      elseif($params['filter'] instanceof Net_LDAP2_Filter) {
        $this -> params['filter'] =& $params['filter'];
      }
    }

    // Approx
    if (isset($params['approx'])) {
      if (is_bool($params['approx']) || $params['approx']==0 || $params['approx']==1) {
        $this -> params['approx'] = (bool)$params['approx'];
      }
      else {
        LSerror :: addErrorCode('LSsearch_05','approx');
        $OK=false;
      }
    }

    // Without Cache
    if (isset($params['withoutCache'])) {
      if (is_bool($params['withoutCache']) || $params['withoutCache']==0 || $params['withoutCache']==1) {
        $this -> params['withoutCache'] = (bool)$params['withoutCache'];
      }
      else {
        LSerror :: addErrorCode('LSsearch_05','withoutCache');
        $OK=false;
      }
    }

    // Patterm
    if (isset($params['pattern'])) {
      if ($params['pattern']=="") {
        $this -> params['pattern'] = NULL;
      }
      elseif ($this -> isValidPattern($params['pattern'])) {
        $this -> params['pattern'] = $params['pattern'];
      }
    }


    // BaseDN
    if (isset($params['basedn']) && is_string($params['basedn'])) {
      if (isCompatibleDNs(LSsession :: getRootDn(),$params['basedn'])) {
        $this -> params['basedn'] = $params['basedn'];
      }
      else {
        LSerror :: addErrorCode('LSsearch_02',$params['basedn']);
        $OK=false;
      }
    }

    // subDn
    if (isset($params['subDn']) && is_string($params['subDn'])) {
      if (LSsession :: validSubDnLdapServer($params['subDn'])) {
        $this -> params['subDn'] = $params['subDn'];
      }
      else {
        LSerror :: addErrorCode('LSsearch_03','subDn');
        $OK=false;
      }
    }

    // Scope
    if (isset($params['scope']) && is_string($params['scope'])) {
      if (in_array($params['scope'],array('sub','one','base'))) {
        $this -> params['scope'] = $params['scope'];
      }
      else {
        LSerror :: addErrorCode('LSsearch_03','scope');
        $OK=false;
      }
    }

    // nbObjectsByPage
    if (isset($params['nbObjectsByPage'])) {
      if (((int)$params['nbObjectsByPage'])>=1 ) {
        $this -> params['nbObjectsByPage'] = (int)$params['nbObjectsByPage'];
      }
      else {
        LSerror :: addErrorCode('LSsearch_03','nbObjectsByPage');
        $OK=false;
      }
    }

    // nbObjectsByPageChoices
    if (isset($params['nbObjectsByPageChoices'])) {
      if (is_array($params['nbObjectsByPageChoices'])) {
        $choices = array();
        $choiceError = false;
        foreach($params['nbObjectsByPageChoices'] as $choice) {
          if (is_int($choice) && !in_array($choice, $choices)) {
            $choices[] = $choice;
          }
          else {
            $choiceError = true;
            break;
          }
        }
        if (!empty($choices) && !$choiceError) {
          $this -> params['nbObjectsByPageChoices'] = $choices;
        }
        else {
          LSerror :: addErrorCode('LSsearch_03','nbObjectsByPageChoices');
          $OK = false;
        }
      }
      else {
        LSerror :: addErrorCode('LSsearch_03','nbObjectsByPageChoices');
        $OK = false;
      }
    }

    // Extra Columns
    if (isset($params['extraDisplayedColumns'])) {
      $this -> params['extraDisplayedColumns']=(bool)$params['extraDisplayedColumns'];
    }

    // Sort Limit
    if (isset($params['sortlimit'])) {
      if (is_int($params['sortlimit']) && $params['sortlimit']>=0 ) {
        $this -> params['sortlimit'] = $params['sortlimit'];
      }
      elseif ((int)$params['sortlimit'] > 0) {
        $this -> params['sortlimit'] = (int)$params['sortlimit'];
      }
      else {
        LSerror :: addErrorCode('LSsearch_03','sortlimit');
        $OK=false;
      }
    }

    // Sort Direction
    if (isset($params['sortDirection']) && is_string($params['sortDirection'])) {
      if (in_array($params['sortDirection'],array('ASC','DESC'))) {
        $this -> params['sortDirection'] = $params['sortDirection'];
      }
      else {
        LSerror :: addErrorCode('LSsearch_03','sortDirection');
        $OK=false;
      }
    }

    // Sort By
    if (isset($params['sortBy']) && is_string($params['sortBy'])) {
      if (in_array($params['sortBy'],array('displayName','subDn')) || ($this ->extraDisplayedColumns && isset($this ->extraDisplayedColumns[$params['sortBy']]))) {
        if ($this -> params['sortBy'] == $params['sortBy']) {
          $this -> toggleSortDirection();
        }
        else {
          $this -> params['sortBy'] = $params['sortBy'];
          if (!isset($params['sortDirection']) || !is_string($params['sortDirection'])) {
            $this -> params['sortDirection'] = 'ASC';
          }
        }
      }
      else {
        LSerror :: addErrorCode('LSsearch_03','sortBy');
        $OK=false;
      }
    }

    // Size Limit
    if (isset($params['sizelimit'])) {
      if (((int)$params['sizelimit']) >= 0) {
        $this -> params['sizelimit'] = $params['sizelimit'];
      }
      else {
        LSerror :: addErrorCode('LSsearch_04');
        $OK=false;
      }
    }

    // Attronly
    if (isset($params['attronly'])) {
      if (is_bool($params['attronly']) || $params['attronly']==0 || $params['attronly']==1) {
        $this -> params['attronly'] = (bool)$params['attronly'];
      }
      else {
        LSerror :: addErrorCode('LSsearch_05','attronly');
        $OK=false;
      }
    }

    // Recursive
    if (isset($params['recursive'])) {
      if (is_bool($params['recursive']) || $params['recursive']==0 || $params['recursive']==1) {
        $this -> params['recursive'] = (bool)$params['recursive'];
      }
      else {
        LSerror :: addErrorCode('LSsearch_05','recursive');
        $OK=false;
      }
    }

    // displaySubDn
    if (isset($params['displaySubDn'])) {
      if (! LSsession :: isSubDnLSobject($this -> LSobject) ) {
        if (is_bool($params['displaySubDn']) || $params['displaySubDn']==0 || $params['displaySubDn']==1) {
          $this -> params['displaySubDn'] = (bool)$params['displaySubDn'];
        }
        else {
          LSerror :: addErrorCode('LSsearch_05','displaySubDn');
          $OK=false;
        }
      }
    }

    // Attributes
    if (isset($params['attributes'])) {
      if (is_string($params['attributes'])) {
        $this -> params['attributes'] = array($params['attributes']);
      }
      elseif (is_array($params['attributes'])) {
        $this -> params['attributes']=array();
        foreach ($params['attributes'] as $attr) {
          if (is_string($attr)) {
            if (LSconfig::get("LSobjects.".$this -> LSobject.".attrs.$attr")) {;
              $this -> params['attributes'][] = $attr;
            }
            else {
              LSerror :: addErrorCode('LSsearch_11',$attr);
            }
          }
        }
      }
      else {
        LSerror :: addErrorCode('LSsearch_06');
        $OK=false;
      }
    }

    // predefinedFilter
    if (isset($params['predefinedFilter'])) {
      if (is_string($params['predefinedFilter'])) {
        if (empty($params['predefinedFilter'])) {
          $this->params['predefinedFilter']=false;
        }
        elseif(is_array($this -> config['predefinedFilters'])) {
          if(isset($this->config['predefinedFilters'][$params['predefinedFilter']])) {
            $this -> params['predefinedFilter'] = $params['predefinedFilter'];
          }
          else {
            LSerror :: addErrorCode('LSsearch_03','predefinedFilter');
            $OK=false;
          }
        }
      }
      else {
        LSerror :: addErrorCode('LSsearch_03','predefinedFilter');
        $OK=false;
      }
    }

    // Display Format
    if (isset($params['displayFormat']) && is_string($params['displayFormat'])) {
      $this -> params['displayFormat'] = $params['displayFormat'];
    }

    // Custom Infos
    if (isset($params['customInfos']) && is_array($params['customInfos'])) {
      foreach($params['customInfos'] as $name => $data) {
        if(is_array($data['function']) && is_string($data['function'][0])) {
          LSsession::loadLSclass($data['function'][0]);
        }
        if (is_callable($data['function'])) {
          $this -> params['customInfos'][$name] = array (
            'function' => &$data['function'],
            'args' => (isset($data['args'])?$data['args']:null),
            'cache' => (isset($data['cache'])?boolval($data['cache']):true),
          );
        }
        else {
          LSerror :: addErrorCode('LSsearch_14',$name);
        }
      }
    }

    // Only Accessible objects
    if (isset($params['onlyAccessible'])) {
      $this -> params['onlyAccessible'] = (bool)$params['onlyAccessible'];
    }

    $this -> saveParamsInSession();
    return $OK;
  }

  /**
   * Return true only if the form is submited
   *
   * @retval boolean True only if the is submited
   **/
  private function formIsSubmited() {
    return isset($_REQUEST['LSsearch_submit']);
  }

  /**
   * Define search parameters by reading request data ($_REQUEST)
   *
   * @retval boolean True if all parameters found in request data are handled, False otherwise
   */
  public function setParamsFromRequest() {
    $allowedParams = array(
      'pattern', 'approx',  'recursive', 'extraDisplayedColumns', 'nbObjectsByPage',
      'attributes', 'sortBy', 'sortDirection', 'withoutCache', 'predefinedFilter',
      // Following parameters are allowed from request but need additional checks
      'filter', 'basedn', 'subDn', 'scope', 'attributes', 'displayFormat',
    );
    $data = array();

    foreach($_REQUEST as $key => $value) {
      if (!in_array($key, $allowedParams))
        continue;
      switch($key) {
        case 'filter':
          // Parse filter to extract attribute name and check if user have read access on it
          // FIXME: Net_LDAP2_Filter could only permit to extract attribute name from a simple
          // filter (without sub-filters), so we currently only access this type of filter.
          $filter = Net_LDAP2_Filter::parse($value);
          if (Net_LDAP2::isError($filter)) {
            LSerror :: addErrorCode('LSsearch_03', 'filter');
            return;
          }
          $filter_parts = $filter -> getComponents();
          if (!is_array($filter_parts) || !LSsession :: canAccess($this -> LSobject, null, 'r', $filter_parts[0])) {
            LSerror :: addErrorCode('LSsearch_03', 'filter');
            return;
          }
          break;

        case 'basedn':
        case 'subDn':
        case 'scope':
          // These parameters could only be used if combined with onlyAccessible==True
          $data['onlyAccessible'] = True;
          break;

        case 'attributes':
          foreach(ensureIsArray($value) as $attr) {
            if (!is_string($attr)) {
              LSerror :: addErrorCode('LSsearch_06');
              return;
            }
            if (!LSsession :: canAccess($this -> LSobject, null, 'r', $attr)) {
              LSerror :: addErrorCode('LSsearch_11', $attr);
              return;
            }
          }
          break;

        case 'displayFormat':
          if (!LSsession :: canComputeLSformat($value, $this -> LSobject)) {
            LSerror :: addErrorCode('LSsearch_11', 'displayFormat');
            return;
          }
          break;
      }
      $data[$key] = $value;
    }

    if (self::formIsSubmited()) {
      // Recursive
      if (is_null($data['recursive'])) {
        $data['recursive']=false;
      }
      else {
        $data['recursive']=true;
      }

      // Approx
      if (is_null($data['approx'])) {
        $data['approx']=false;
      }
      else {
        $data['approx']=true;
      }

      if (isset($data['ajax']) && !isset($data['pattern'])) {
        $data['pattern']="";
      }
    }

    return (empty($data)?true:$this -> setParams($data));
  }

  /**
   * Toggle the sort direction
   *
   * @retval void
   **/
  private function toggleSortDirection() {
    if ($this -> params['sortDirection']=="ASC") {
      $this -> params['sortDirection'] = "DESC";
    }
    else {
      $this -> params['sortDirection'] = "ASC";
    }
  }

  /**
   * Make a filter object with a pattern of search
   *
   * @param[in] $pattern The pattern of search. If is null, the pattern in params will be used.
   *
   * @retval mixed Net_LDAP2_Filter on success or False
   */
  public function getFilterFromPattern($pattern=NULL) {
    if ($pattern==NULL) {
      $pattern=$this -> params['pattern'];
    }
    if ($this -> isValidPattern($pattern)) {
      $attrsConfig=LSconfig::get("LSobjects.".$this -> LSobject.".LSsearch.attrs");
      $attrsList=array();
      if (!is_array($attrsConfig)) {
        foreach(LSconfig::get("LSobjects.".$this -> LSobject.".attrs") as $attr => $config) {
          $attrsList[$attr]=array();
        }
      }
      else {
        foreach($attrsConfig as $key => $val) {
          if(is_int($key)) {
            $attrsList[$val]=array();
          }
          else {
            $attrsList[$key]=$val;
          }
        }
      }

      if (empty($attrsList)) {
        LSerror :: addErrorCode('LSsearch_07');
        return;
      }

      $filters=array();
      foreach ($attrsList as $attr => $opts) {
        if ($this -> params['approx']) {
          if (isset($opts['approxLSformat'])) {
            $filter=Net_LDAP2_Filter::parse(getFData($opts['approxLSformat'],array('name'=>$attr,'pattern'=>$pattern)));
          }
          else {
            $filter=Net_LDAP2_Filter::create($attr,'approx',$pattern);
          }
        }
        else {
          if (isset($opts['searchLSformat'])) {
            $filter=Net_LDAP2_Filter::parse(getFData($opts['searchLSformat'],array('name'=>$attr,'pattern'=>$pattern)));
          }
          else {
            $filter=Net_LDAP2_Filter::create($attr,'contains',$pattern);
          }
        }

        if (!Net_LDAP2::isError($filter)) {
          $filters[]=$filter;
        }
        else {
          LSerror :: addErrorCode('LSsearch_08',array('attr' => $attr,'pattern' => $pattern));
          return;
        }
      }
      if(!empty($filters)) {
        $filter=LSldap::combineFilters('or',$filters);
        if ($filter) {
          return $filter;
        }
        else {
          LSerror :: addErrorCode('LSsearch_09');
        }
      }
    }
    else {
      LSerror :: addErrorCode('LSsearch_10');
    }
    return;
  }

  /**
   * Check if search pattern is valid
   *
   * @param[in] $pattern string The pattern
   *
   * @retval boolean True if pattern is valid or False
   **/
  public function isValidPattern($pattern) {
    if (is_string($pattern) && $pattern!= "") {
      $regex = (isset($this -> config['validPatternRegex'])?$this -> config['validPatternRegex']:'/^[\w \-\_\\\'\"^\[\]\(\)\{\}\=\+\£\%\$\€\.\:\;\,\?\/\@]+$/iu');
      if (preg_match($regex, $pattern))
        return True;
    }
    LSerror :: addErrorCode('LSsearch_17');
    return False;
  }

  /**
   * Check if cache is enabled
   *
   * @retval boolean True if cache is enabled or False
   **/
  public function cacheIsEnabled() {
    if (isset($this -> config['cache'])) {
      $conf=$this -> config['cache'];
      if (is_bool($conf) || $conf==0 || $conf==1) {
        return (bool)$conf;
      }
      else {
        LSerror :: addErrorCode('LSsearch_03','cache');
      }
    }
    return LSsession :: cacheSearch();
  }

  /**
   * Methode for parameters value access
   *
   * @param[in] $key string The parameter name
   *
   * @retval mixed The parameter value or NULL
   **/
  public function getParam($key) {
    if(in_array($key,array_keys($this -> params))) {
      if ($key == 'nbObjectsByPageChoices' && !is_array($this -> params['nbObjectsByPageChoices'])) {
        return (isset($GLOBALS['NB_LSOBJECT_LIST_CHOICES']) && is_array($GLOBALS['NB_LSOBJECT_LIST_CHOICES'])?$GLOBALS['NB_LSOBJECT_LIST_CHOICES']:range(NB_LSOBJECT_LIST, NB_LSOBJECT_LIST*4, NB_LSOBJECT_LIST));
      }
      return $this -> params[$key];
    }
    return NULL;
  }

  /**
   * Return hidden fileds to add in search form
   *
   * @retval array The hield fields whith their values
   **/
  public function getHiddenFieldForm() {
    return array (
      'LSobject' => $this -> LSobject
    );
  }

  /**
   * Generate an array with search parameters, only parameters whitch have to be
   * passed to Net_LDAP2 for the LDAP search. This array will be store in
   * $this -> _searchParams private variable.
   *
   * @retval void
   **/
  private function generateSearchParams() {
    // Base
    $retval = array(
      'filter' => $this -> params['filter'],
      'basedn' => $this -> params['basedn'],
      'scope' => $this -> params['scope'],
      'sizelimit' => $this -> params['sizelimit'],
      'attronly' => $this -> params['attronly'],
      'attributes' => $this -> params['attributes']
    );

    // Pattern
    if (!is_null($this -> params['pattern'])) {
      $filter=$this ->getFilterFromPattern();
      if (is_null($retval['filter'])) {
        $retval['filter']=$filter;
      }
      else {
        $retval['filter']=LSldap::combineFilters('and',array($retval['filter'],$filter));
      }
    }

    // predefinedFilter
    if (is_string($this -> params['predefinedFilter'])) {
      if (!is_null($retval['filter'])) {
        $filter=LSldap::combineFilters('and',array($this -> params['predefinedFilter'],$retval['filter']));
        if ($filter) {
          $retval['filter']=$filter;
        }
      }
      else {
        $retval['filter']=$this -> params['predefinedFilter'];
      }
    }

    // Filter
    $objFilter=LSldapObject::_getObjectFilter($this -> LSobject);
    if ($objFilter) {
      if (!is_null($retval['filter'])) {
        $filter=LSldap::combineFilters('and',array($objFilter,$retval['filter']));
        if ($filter) {
          $retval['filter']=$filter;
        }
      }
      else {
        $retval['filter']=$objFilter;
      }
    }

    // Recursive
    if (is_null($retval['basedn'])) {
      if (!is_null($this -> params['subDn'])) {
        if ($this -> params['recursive']) {
          $retval['basedn'] = $this -> params['subDn'];
        }
        else {
          $retval['basedn'] = LSconfig::get("LSobjects.".$this -> LSobject.".container_dn").','.$this -> params['subDn'];
        }
      }
      else {
        if ($this -> params['recursive']) {
          $retval['basedn'] = LSsession :: getTopDn();
        }
        else {
          $retval['basedn'] = LSconfig::get("LSobjects.".$this -> LSobject.".container_dn").','.LSsession :: getTopDn();
        }
      }
    }
    if ($this -> params['recursive'] || !isset($retval['scope'])) {
      $retval['scope'] = 'sub';
    }

    if (is_null($this -> params['displayFormat'])) {
      $this -> params['displayFormat']=LSconfig::get("LSobjects.".$this -> LSobject.".display_name_format");
    }

    // Display Format
    $attrs=getFieldInFormat($this -> params['displayFormat']);
    if(is_array($retval['attributes'])) {
      $retval['attributes']=array_merge($attrs,$retval['attributes']);
    }
    else {
      $retval['attributes']=$attrs;
    }

    // Extra Columns
    if ($this -> params['extraDisplayedColumns'] && is_array($this -> config['extraDisplayedColumns'])) {
      foreach ($this -> config['extraDisplayedColumns'] as $id => $conf) {
        $attrs=array();
        if (isset($conf['LSformat'])) {
          $attrs=getFieldInFormat($conf['LSformat']);
          if (isset($conf['alternativeLSformats'])) {
            if(is_array($conf['alternativeLSformats'])) {
              foreach ($conf['alternativeLSformats'] as $format) {
                $attrs = array_merge($attrs, getFieldInFormat($format));
              }
            }
            else {
              $attrs = array_merge($attrs, getFieldInFormat($conf['alternativeLSformats']));
            }
          }
          if(isset($conf['formaterLSformat'])) {
            $attrs=array_unique(array_merge($attrs,getFieldInFormat($conf['formaterLSformat'])));
            if(($key = array_search('val', $attrs)) !== false) {
              unset($attrs[$key]);
            }
          }
        }
        if(isset($conf['additionalAttrs'])) {
          $attrs=array_unique(array_merge($attrs,(is_array($conf['additionalAttrs'])?$conf['additionalAttrs']:array($conf['additionalAttrs']))));
        }
        if(is_array($retval['attributes'])) {
          $retval['attributes']=array_merge($attrs,$retval['attributes']);
        }
        else {
          $retval['attributes']=$attrs;
        }
      }
    }

    if (is_array($retval['attributes'])) {
      $retval['attributes']=array_unique($retval['attributes']);
    }

    $this -> _searchParams = $retval;
  }

  /**
   * Format search parameters for logging
   *
   * @retval string|null Formated search parameters is defined, or null if not
   **/
  private function formatSearchParams() {
    if (!$this -> _searchParams)
      return;
    if ($this -> _searchParams['filter'] instanceof Net_LDAP2_Filter)
      $return = "filter=".$this -> _searchParams['filter']->asString();
    else
      $return = "without filter";
    $return .= ", on basedn '".$this -> _searchParams['basedn']."'";
    $return .= " (scope: ".($this -> _searchParams['scope']?$this -> _searchParams['scope']:'default');
    if ($this -> _searchParams['attronly'])
      $return .= ", attrs only)";
    else
      $return .= ", attrs: ".(
        (is_array($this -> _searchParams['attributes']) && $this -> _searchParams['attributes'])?
        implode(',', $this -> _searchParams['attributes']):
        'all'
      ).")";
    return $return;
  }

  /**
   * Get search attributes
   *
   * @retval array The attributes asked in this search
   **/
  public function getAttributes() {
    if (!$this -> _searchParams)
      $this -> generateSearchParams();
    return $this -> _searchParams['attributes'];
  }

  /**
   * Run the search
   *
   * @param[in] $cache boolean Define if the cache can be used
   *
   * @retval boolean True on success or False
   */
  public function run($cache=true) {
    $this -> generateSearchParams();
    self :: log_debug($this." -> run(".($cache?'with cache':'without cache').")");

    if( $cache && (!isset($_REQUEST['refresh'])) && (!$this -> params['withoutCache']) ) {
      self :: log_debug($this.' -> run(): Cache enabled');
      $this -> result = $this -> getResultFromCache();
      if ($this -> result)
        self :: log_debug($this.' -> run(): result retrieved from cache');
      else
        self :: log_debug($this.' -> run(): result not found in cache');
    }
    else {
      self :: log_debug($this.' -> run(): Cache disabled');
      $this -> setParam('withoutCache', false);
    }

    if (!$this -> result) {
      $this -> result=array(
        'sortBy' => NULL,
        'sortDirection' => NULL
      );

      // Search in LDAP
      $list = LSldap :: search(
        $this -> _searchParams['filter'],
        $this -> _searchParams['basedn'],
        $this -> _searchParams
      );

      // Check result
      if ($list === false) {
        LSerror :: addErrorCode('LSsearch_12');
        return;
      }

      // Handle onlyAccessible parameter
      if ($this -> getParam('onlyAccessible') && LSsession :: getLSuserObjectDn()) {
        self :: log_debug($this.' -> run(): Filter on only accessible object');
        $this -> result['list'] = array();

        // Check user rights on objets
        foreach($list as $id => $obj) {
          if (LSsession :: canAccess($this -> LSobject, $obj['dn'])) {
            $this -> result['list'][] = $obj;
          }
        }
      }
      else
        $this -> result['list'] = $list;
      $this -> addResultToCache();
    }

    self :: log_debug($this.' -> run(): '.$this -> total. " object(s) found");

    $this -> doSort();

    return true;
  }

  /**
   * Return an hash corresponding to the parameters of the search
   *
   * @param[in] $searchParams array An optional search params array
   * @param[in] $onlyAccessible boolean An optional onlyAccessible boolean flag
   *
   * @retval string The hash of the parameters of the search
   **/
  public function getHash($searchParams=null, $onlyAccessible=null) {
    if (is_null($searchParams)) {
      $searchParams = $this -> _searchParams;
    }
    if (!$searchParams)
      return false;
    if ($searchParams['filter'] instanceof Net_LDAP2_Filter) {
      $searchParams['filter'] = $searchParams['filter'] -> asString();
    }
    $to_hash = print_r($searchParams, true);
    if (is_null($onlyAccessible)) {
      $onlyAccessible = ($this -> getParam('onlyAccessible') && LSsession :: getLSuserObjectDn());
    }
    $to_hash .= '-onlyAccessible='.intval($onlyAccessible);
    return hash('md5', print_r($searchParams, true));
  }

  /**
   * Add the result of the search to cache of the session
   *
   * @retval void
   **/
  public function addResultToCache() {
    if ($this -> cacheIsEnabled()) {
      $hash = $this->getHash();
      self :: log_trace("addResultToCache(): Save result in cache with hash '$hash'.");
      $_SESSION['LSsession']['LSsearch'][$this -> LSobject][$hash]=$this->result;
    }
    else
      self :: log_trace('addResultToCache(): cache is disabled.');
  }

  /**
   * Get the result of the search from cache of the session
   *
   * @retval array | False The array of the result of the search or False
   **/
  private function getResultFromCache() {
    if ($this -> cacheIsEnabled()) {
      $hash=$this->getHash();
      if (isset($_SESSION['LSsession']['LSsearch'][$this -> LSobject][$hash])) {
        self :: log_trace('getResultFromCache(): result found in cache.');
        return $_SESSION['LSsession']['LSsearch'][$this -> LSobject][$hash];
      }
      self :: log_trace('getResultFromCache(): result not found in cache.');
    }
    else
      self :: log_trace('getResultFromCache(): cache is disabled.');
    return;
  }

  /**
   * Get page informations to display
   *
   * @param[in] $page integer The number of the page
   *
   * @retval array The information of the page
   **/
  public function getPage($page=1) {
    if (!LSsession::loadLSclass('LSsearchEntry')) {
      LSerror::addErrorCode('LSsession_05',$this -> LSobject);
      return;
    }
    $page = (int)$page;
    if ($page < 1)
      $page = 1;

    $retval = array(
      'nb' => $page,
      'nbPages' => 1,
      'list' => array(),
      'total' => $this -> total
    );

    if ($retval['total'] > 0) {
      if (!$this->params['nbObjectsByPage']) {
        $this->params['nbObjectsByPage'] = NB_LSOBJECT_LIST;
      }
      $retval['nbPages'] = ceil($retval['total'] / $this->params['nbObjectsByPage']);

      $sortTable=$this -> getSortTable();

      $list = array_slice(
        $sortTable,
        (($page - 1) * $this->params['nbObjectsByPage']),
        $this->params['nbObjectsByPage']
      );

      foreach ($list as $key => $id) {
        $retval['list'][] = new LSsearchEntry(
          $this,
          $this -> LSobject,
          $this -> params,
          $this -> result['list'],
          $id
        );
      }
    }
    return $retval;
  }

  /**
   * Get search entries
   *
   * @retval array The entries
   **/
  public function getSearchEntries() {
    if (!LSsession::loadLSclass('LSsearchEntry')) {
      LSerror::addErrorCode('LSsession_05',$this -> LSobject);
      return;
    }
    $retval=array();
    if ($this -> total>0) {
      $sortTable=$this -> getSortTable();

      foreach ($sortTable as $key => $id) {
        $retval[] = new LSsearchEntry(
          $this,
          $this -> LSobject,
          $this -> params,
          $this -> result['list'],
          $id
        );
      }
    }
    return $retval;
  }

  /**
   * Access to information of this object
   *
   * @param[in] $key string The key of the info
   *
   * @retval mixed The info
   **/
  public function __get($key) {
    $params = array (
      'basedn',
      'sortBy',
      'sortDirection',
      'attributes',
    );
    if ($key=='LSobject') {
      return $this -> LSobject;
    }
    elseif (in_array($key,$params)) {
      return $this -> params[$key];
    }
    elseif ($key=='label_objectName') {
      return LSldapObject::getLabel($this -> LSobject);
    }
    elseif ($key=='label_level') {
      return LSsession :: getSubDnLabel();
    }
    elseif ($key=='label_actions') {
      return _('Actions');
    }
    elseif ($key=='label_no_result') {
      return _("This search didn't get any result.");
    }
    elseif ($key=='sort') {
      if (isset($this -> params['sortlimit']) && ($this -> params['sortlimit']>0)) {
        return ($this -> total < $this -> params['sortlimit']);
      }
      return true;
    }
    elseif ($key=='sortlimit') {
      return $this -> params['sortlimit'];
    }
    elseif ($key=='total') {
      return count($this -> result['list']);
    }
    elseif ($key=='label_total') {
      return $this -> total." ".$this -> label_objectName;
    }
    elseif ($key=='displaySubDn') {
      if (LSsession :: subDnIsEnabled()) {
        if (!is_null($this -> params[$key])) {
          return $this -> params[$key];
        }
        else {
          return (! LSsession :: isSubDnLSobject($this -> LSobject) );
        }
      }
      return false;
    }
    elseif ($key=='canCopy') {
      if (!is_null($this -> _canCopy))
        return $this -> _canCopy;
      $this -> _canCopy = LSsession :: canCreate($this -> LSobject);
      return $this -> _canCopy;
    }
    elseif ($key=='predefinedFilters') {
      $retval=array();
      if (is_array($this -> config['predefinedFilters'])) {
        foreach($this -> config['predefinedFilters'] as $filter => $label) {
          $retval[$filter]=__($label);
        }
      }
      return $retval;
    }
    elseif ($key=='extraDisplayedColumns') {
      if ($this->params['extraDisplayedColumns'] && is_array($this -> config['extraDisplayedColumns'])) {
        return $this -> config['extraDisplayedColumns'];
      }
      else {
        return False;
      }
    }
    elseif ($key=='visibleExtraDisplayedColumns') {
      if ($this->params['extraDisplayedColumns'] && is_array($this -> config['extraDisplayedColumns'])) {
        $ret=array();
        foreach($this->config['extraDisplayedColumns'] as $col => $conf) {
          if (isset($conf['visibleTo']) && !LSsession :: isLSprofiles($this -> basedn, $conf['visibleTo'])) {
            continue;
          }
          $ret[$col]=$conf;
        }
        return $ret;
      }
    }
    elseif ($key == 'hash') {
      return $this -> getHash();
    }
    else {
      throw new Exception("Incorrect property '$key'!");
    }
  }

  /**
   * Function use with uasort to sort two entry
   *
   * @param[in] $a array One line of result
   * @param[in] $b array One line of result
   *
   * @retval int Value for uasort
   **/
  private function _sortTwoEntry(&$a,&$b) {
    $sortBy = $this -> params['sortBy'];
    $sortDirection = $this -> params['sortDirection'];
    if ($sortDirection=='ASC') {
      $dir = 1;
    }
    else {
      $dir = -1;
    }
    $oa = new LSsearchEntry($this, $this -> LSobject, $this -> params, $this -> result['list'], $a);
    $va = $oa->$sortBy;
    $ob = new LSsearchEntry($this, $this -> LSobject, $this -> params, $this -> result['list'], $b);
    $vb = $ob->$sortBy;

    if ($va == $vb) return 0;

    $val = strnatcmp(strtolower($va), strtolower($vb));
    return $val*$dir;
  }

  /**
   * Function to run after using the result. It's update the cache
   *
   * IT'S FUNCTION IS VERY IMPORTANT !!!
   *
   * @retval void
   **/
  public function afterUsingResult() {
    $this -> addResultToCache();
  }

  /**
   * Redirect user to object view if the search have only one result
   *
   * @retval boolean True only if user have been redirected
   **/
  public function redirectWhenOnlyOneResult() {
    if ($this -> total == 1 && $this -> result && self::formIsSubmited()) {
      LSurl :: redirect('object/'.$this -> LSobject.'/'.urlencode($this -> result['list'][0]['dn']));
    }
    return;
  }

  /**
   * Run the sort if it's enabled and if the result is not in the cache
   *
   * @retval boolean True on success or false
   **/
  private function doSort() {
    if (!$this -> sort) {
      self :: log_debug('doSort(): sort is disabled');
      return true;
    }
    if (is_null($this -> params['sortBy'])) {
      return;
    }
    if (is_null($this -> params['sortDirection'])) {
      $this -> params['sortDirection']='ASC';
    }

    if ($this->total==0) {
      return true;
    }

    if (isset($this -> result['sort'][$this -> params['sortBy']][$this -> params['sortDirection']])) {
      self :: log_debug('doSort(): from cache');
      return true;
    }

    self :: log_debug('doSort(): sort by "'.$this -> params['sortBy'].'" (order: '.$this -> params['sortDirection']).")";

    $this -> result['sort'][$this -> params['sortBy']][$this -> params['sortDirection']]=range(0,($this -> total-1));

    if (!LSsession :: loadLSClass('LSsearchEntry')) {
      LSerror::addErrorCode('LSsession_05','LSsearchEntry');
      return;
    }

    if (!uasort(
      $this -> result['sort'][$this -> params['sortBy']][$this -> params['sortDirection']],
      array($this,'_sortTwoEntry')
    )) {
      LSerror :: addErrorCode('LSsearch_13');
      return;
    }

    return true;
  }

  /**
   * Returns the id of table rows in the result sorted according to criteria
   * defined in the parameters
   *
   * @retval array The Table of id lines of results sorted
   **/
  public function getSortTable() {
    if (isset($this -> result['sort'][$this -> params['sortBy']][$this -> params['sortDirection']])) {
      return $this -> result['sort'][$this -> params['sortBy']][$this -> params['sortDirection']];
    }
    return range(0,($this -> total-1));
  }

  /**
   * List LSsearchEntry objects
   *
   * @retval Array DN associate with name
   **/
  public function listEntries() {
    if (!LSsession::loadLSclass('LSsearchEntry')) {
      LSerror::addErrorCode('LSsession_05',$this -> LSobject);
      return;
    }

    $retval=array();

    if ($this -> total>0) {
      $sortTable = $this -> getSortTable();

      foreach ($sortTable as $key => $id) {
        $entry = new LSsearchEntry(
          $this,
          $this -> LSobject,
          $this -> params,
          $this -> result['list'],
          $id
        );
        $retval[$entry -> dn] = $entry;
      }
    }

    return $retval;
  }

  /**
   * List objects name
   *
   * @retval Array DN associate with name
   **/
  public function listObjectsName() {
    $entries = $this -> listEntries();
    if (!is_array($entries))
      return;
    $retval = array();
    foreach($entries as $entry)
      $retval[$entry -> dn] = $entry -> displayName;
    return $retval;
  }

  /**
   * List LSldapObjects
   *
   * @retval Array of LSldapObjects
   **/
  public function listObjects() {
    $retval=array();

    if ($this -> total>0) {
      $sortTable=$this -> getSortTable();

      $c=0;
      foreach ($sortTable as $key => $id) {
        $retval[$c]=new $this -> LSobject();
        $retval[$c] -> loadData($this -> result['list'][$id]['dn']);
        $c++;
      }
    }

    return $retval;
  }

  /**
   * List objects dn
   *
   * @retval Array of DN
   **/
  public function listObjectsDn() {
    $retval=array();

    if ($this -> total>0) {
      $sortTable=$this -> getSortTable();

      $c=0;
      foreach ($sortTable as $key => $id) {
        $retval[$c] = $this -> result['list'][$id]['dn'];
        $c++;
      }
    }

    return $retval;
  }

  /**
   * CLI search command
   *
   * @param[in] $command_args array Command arguments :
   *   - Positional arguments :
   *     - LSobject type
   *     - patterns
   *   - Optional arguments :
   *     - -f|--filter : LDAP filter string
   *     - -b|--basedn : LDAP base DN
   *     - -s|--scope : LDAP search scope (sub, one, base)
   *     - -l|--limit : search result size limit
   *     - -a|--approx : approximative search on provided pattern
   *     - -r|--recursive : recursive search
   *     - --sort-by : Sort by specific attribute/column
   *     - -R|--reverse : reverse search result
   *     - --sort-limit : Sort limit (in number of objects found)
   *     - --display-subdn : Display subDn in result
   *     - --display-format : Display format of objectName
   *     - -N|--nb-obj-by-page : number of object by page
   *     - -W|--without-cache : Disable cache
   *     - -e|--extra-columns : Display extra columns
   *     - -p|--page : page number to show (starting by 1, default: first one)
   *
   * @retval boolean True on success, false otherwise
   **/
  public static function cli_search($command_args) {
    $objType = null;
    $patterns = array();
    $params = array(
      'sortDirection' => 'ASC',
      'extraDisplayedColumns' => false,
    );
    $page_nb = 1;
    $all = false;
    $json = false;
    $pretty = false;
    for ($i=0; $i < count($command_args); $i++) {
      switch ($command_args[$i]) {
        case '-f':
        case '--filter':
          $params['filter'] = $command_args[++$i];
          break;
        case '-b':
        case '--basedn':
          $params['basedn'] = $command_args[++$i];
          break;
        case '-s':
        case '--scope':
          $params['scope'] = $command_args[++$i];
          break;
        case '-s':
        case '--scope':
          $params['scope'] = $command_args[++$i];
          break;
        case '-l':
        case '--limit':
          $params['sizelimit'] = intval($command_args[++$i]);
          break;
        case '-a':
        case '--approx':
          $params['approx'] = true;
          break;
        case '-r':
        case '--recursive':
          $params['recursive'] = true;
          break;
        case '--sort-by':
          $params['sortBy'] = $command_args[++$i];
          break;
        case '-R':
        case '--reverse':
          $params['sortDirection'] = 'DESC';
          break;
        case '--sort-limit':
          $params['sortlimit'] = intval($command_args[++$i]);
          break;
        case '--sort-limit':
          $params['sortlimit'] = intval($command_args[++$i]);
          break;
        case '--display-subdn':
          $params['displaySubDn'] = true;
          break;
        case '--display-format':
          $params['displayFormat'] = boolval($command_args[++$i]);
          break;
        case '-N':
        case '--nb-obj-by-page':
          $params['nbObjectsByPage'] = intval($command_args[++$i]);
          break;
        case '-W':
        case '--without-cache':
          $params['withoutCache'] = True;
          break;
        case '-e':
        case '--extra-columns':
          $params['extraDisplayedColumns'] = True;
          break;
        case '-p':
        case '--page':
          $page_nb = intval($command_args[++$i]);
          break;
        case '--all':
          $all = true;
          break;
        case '-j':
        case '--json':
          $json = true;
          break;
        case '--pretty':
          $pretty = true;
          break;
        default:
          if (is_null($objType)) {
            $objType = $command_args[$i];
          }
          elseif (substr($command_args[$i], 0, 1) == '-') {
            LScli :: usage("Invalid parameter '".$command_args[$i]."'");
          }
          else {
            $patterns[] = $command_args[$i];
          }
      }
    }

    if (is_null($objType))
      LScli :: usage('You must provide LSobject type.');

    // Load Console Table lib
    $console_table_path = LSconfig :: get('ConsoleTable', 'Console/Table.php', 'string');
    if (!LSsession :: includeFile($console_table_path, true))
      self :: log_fatal('Fail to load ConsoleTable library.');

    if (!empty($patterns))
      $params['pattern'] = implode(' ', $patterns);

    $search = new LSsearch($objType, 'CLI', array(), true);

    // Set search params
    self :: log_debug('Search parameters : '.varDump($params));
    if (!$search -> setParams($params))
      self :: log_fatal('Fail to set search parameters.');

    // Run search
    if (!$search -> run())
      self :: log_fatal('Fail to run search.');


    if ($all) {
      $entries = $search -> listEntries();
      if (!is_array($entries))
        self :: log_fatal("Fail to retrieve search result");
    }
    else {
      // Retrieve page
      $page = $search -> getPage($page_nb);
      /*
       * $page = array(
       *   'nb' => $page,
       *   'nbPages' => 1,
       *   'list' => array(),
       *   'total' => $this -> total
       * );
       */

      // Check page
      if (!is_array($page) || $page_nb > $page['nbPages'])
        self :: log_fatal("Fail to retrieve page #$page_nb.");
    }

    // Handle JSON output
    if ($json) {
      $export = array(
        'objects' => array(),
        'total' => $search -> total,
      );
      if (!$all) {
        $export['page'] = $page['nb'];
        $export['nbPages'] = $page['nbPages'];
      }
      foreach(($all?$entries:$page['list']) as $obj) {
        $export['objects'][$obj -> dn] = array(
          'name' => $obj -> displayName,
        );
        if ($search -> displaySubDn)
          $export['objects'][$obj -> dn][$search -> label_level] = $obj -> subDn;
        if ($search -> extraDisplayedColumns) {
          foreach ($search -> visibleExtraDisplayedColumns as $cid => $conf) {
            $export['objects'][$obj -> dn][$conf['label']] = $obj -> $cid;
          }
        }
      }
      $output = json_encode($export, ($pretty?JSON_PRETTY_PRINT:0));
      if ($output === false) {
        self :: log_error("Fail to encode data as JSON");
        exit(1);
      }
      echo $output;
      exit(0);
    }

    if (empty($all?$entries:$page['list'])) {
      echo "No $objType object found.\n";
      exit(0);
    }

    // Create result table with its header
    $tbl = new Console_Table();
    $headers = array('DN', 'Name');
    if ($search -> displaySubDn)
      $headers[] = $search -> label_level;
    if ($search -> extraDisplayedColumns) {
      foreach ($search -> visibleExtraDisplayedColumns as $cid => $conf) {
        $headers[] = $conf['label'];
      }
    }
    $tbl->setHeaders($headers);

    // Add one line for each object found (in page)
    foreach($all?$entries:$page['list'] as $obj) {
      $row = array(
        $obj -> dn,
        $obj -> displayName,
      );
      if ($search -> displaySubDn)
        $row[] = $obj -> subDn;
      if ($search -> extraDisplayedColumns) {
        foreach ($search -> visibleExtraDisplayedColumns as $cid => $conf) {
          $row[] = $obj -> $cid;
        }
      }
      $tbl->addRow($row);
    }
    echo $tbl->getTable();
    if ($all)
      echo "Total: ".$search -> total."\n";
    else
      echo "Page ".($page['nb'])." on ".$page['nbPages']." / Total: ".$search -> total."\n";

    return true;
  }

  /**
   * Args autocompleter for CLI command search
   *
   * @param[in] $command_args array List of already typed words of the command
   * @param[in] $comp_word_num int The command word number to autocomplete
   * @param[in] $comp_word string The command word to autocomplete
   * @param[in] $opts array List of global available options
   *
   * @retval array List of available options for the word to autocomplete
   **/
  public static function cli_search_args_autocompleter($command_args, $comp_word_num, $comp_word, $opts) {
    $command_opts = array (
      '-f', '--filter',
      '-b', '--basedn',
      '-s', '--scope',
      '-l', '--limit',
      '-a', '--approx',
      '-r', '--recursive',
      '--sort-by',
      '-R', '--reverse',
      '--sort-limit',
      '--display-subdn',
      '--display-format',
      '-N', '--nb-obj-by-page',
      '-W', '--without-cache',
      '-e', '--extra-columns',
      '-p', '--page',
      '--all',
      '-j', '--json', '--pretty',
    );

    // Detect positional args
    $objType = null;
    $objType_arg_num = null;
    $patterns = array();
    $extra_columns = false;
    for ($i=0; $i < count($command_args); $i++) {
      if (!in_array($command_args[$i], $command_opts) || in_array($command_args[$i], $opts)) {
        // If object type not defined
        if (is_null($objType)) {
          // Check object type exists
          $objTypes = LScli :: autocomplete_LSobject_types($command_args[$i]);

          // Load it if exist and not trying to complete it
          if (in_array($command_args[$i], $objTypes) && $i != $comp_word_num) {
            LSsession :: loadLSobject($command_args[$i], false);
          }

          // Defined it
          $objType = $command_args[$i];
          $objType_arg_num = $i;
        }
        else
          $patterns[] = $command_args[$i];
      }
      else {
        switch ($command_args[$i]) {
          case '-s':
          case '--scope':
          case '-f':
          case '--filter':
          case '-b':
          case '--basedn':
          case '-l':
          case '--limit':
          case '--sort-limit':
          case '-N':
          case '--nb-obj-by-page':
          case '-p':
          case '--page':
          case '--sort-by':
            // This args accept options => increase $i
            $i++;
            break;
          case '-e':
          case '--extra-columns':
            $extra_columns = true;
            LSlog :: debug('Extra columns enabled');
            break;
        }
      }
    }

    // Handle completion of args value
    LSlog :: debug("Last complete word = '".$command_args[$comp_word_num-1]."'");
    switch ($command_args[$comp_word_num-1]) {
      case '-s':
      case '--scope':
        return LScli :: autocomplete_opts(array('sub', 'one', 'base'), $comp_word);
      case '-f':
      case '--filter':
      case '-b':
      case '--basedn':
        // This args need string value that can't be autocomplete: stop autocompletion
        return array();
      case '-l':
      case '--limit':
      case '--sort-limit':
      case '-N':
      case '--nb-obj-by-page':
      case '-p':
      case '--page':
        return LScli :: autocomplete_int($comp_word);
      case '--sort-by':
        $bys = array('displayName', 'subDn');
        if ($objType && $extra_columns) {
          $extraDisplayedColumns = LSconfig::get("LSobjects.$objType.LSsearch.extraDisplayedColumns", array());
          if (is_array($extraDisplayedColumns))
            $bys = array_merge($bys, array_keys($extraDisplayedColumns));
        }
        LSlog :: debug('Available sort-bys clauses: '.implode(', ', $bys));
        return LScli :: autocomplete_opts($bys, $comp_word);
    }
    $opts = array_merge($opts, $command_opts);

    // If objType not already choiced (or currently autocomplete), add LSobject types to available options
    if (!$objType || $objType_arg_num == $comp_word_num)
      $opts = array_merge($opts, LScli :: autocomplete_LSobject_types($comp_word));

    return LScli :: autocomplete_opts($opts, $comp_word);
  }
}

/**
 * Error Codes
 **/
LSerror :: defineError('LSsearch_01',
___("LSsearch : Invalid filter : %{filter}.")
);
LSerror :: defineError('LSsearch_02',
___("LSsearch : Invalid basedn : %{basedn}.")
);
LSerror :: defineError('LSsearch_03',
___("LSsearch : Invalid value for %{param} parameter.")
);
LSerror :: defineError('LSsearch_04',
___("LSsearch : Invalid size limit. Must be an integer greater or equal to 0.")
);
LSerror :: defineError('LSsearch_05',
___("LSsearch : Invalid parameter %{attr}. Must be an boolean.")
);
LSerror :: defineError('LSsearch_06',
___("LSsearch : Invalid parameter attributes. Must be an string or an array of strings.")
);
LSerror :: defineError('LSsearch_07',
___("LSsearch : Can't build attributes list for make filter.")
);
LSerror :: defineError('LSsearch_08',
___("LSsearch : Error building filter with attribute '%{attr}' and pattern '%{pattern}'")
);
LSerror :: defineError('LSsearch_09',
___("LSsearch : Error combining filters.")
);
LSerror :: defineError('LSsearch_10',
___("LSsearch : Invalid pattern.")
);
LSerror :: defineError('LSsearch_11',
___("LSsearch : Invalid attribute %{attr} in parameters.")
);
LSerror :: defineError('LSsearch_12',
___("LSsearch : Error during the search.")
);
LSerror :: defineError('LSsearch_13',
___("LSsearch : Error sorting the search.")
);
LSerror :: defineError('LSsearch_14',
___("LSsearch : The function of the custum information %{name} is not callable.")
);
LSerror :: defineError('LSsearch_15',
___("LSsearch : Invalid predefinedFilter for LSobject type %{type} : %{label} (filter : %{filter}).")
);
LSerror :: defineError('LSsearch_16',
___("LSsearch : Error during execution of the custom action %{customAction}.")
);
LSerror :: defineError('LSsearch_17',
___("LSsearch : Invalid search pattern.")
);

// LScli
LScli :: add_command(
    'search',
    array('LSsearch', 'cli_search'),
    'Search LSobject',
    '[object type] [pattern1] [pattern2 ...]',
    array(
    '   - Positional arguments :',
    '     - LSobject type',
    '     - patterns',
    '',
    '   - Optional arguments :',
    '     - -f|--filter : LDAP filter string',
    '     - -b|--basedn : LDAP base DN',
    '     - -s|--scope : LDAP search scope (sub, one, base)',
    '     - -l|--limit : search result size limit',
    '     - -a|--approx : approximative search on provided pattern',
    '     - -r|--recursive : recursive search',
    '     - --sort-by : Sort by specific attribute/column',
    '     - -R|--reverse : reverse search result',
    '     - --sort-limit : Sort limit (in number of objects found)',
    '     - --display-subdn : Display subDn in result',
    '     - --display-format : Display format of objectName',
    '     - -N|--nb-obj-by-page : number of object by page',
    '     - -W|--without-cache : Disable cache',
    '     - -e|--extra-columns : Display extra columns',
    '     - -p|--page : page number to show (starting by 1, default: first one)',
    '     - --all : list all matching objects (no pagination)',
    '     - -j|--json : JSON output',
    '     - --pretty : prettify the JSON output',
  ),
  true,
  array('LSsearch', 'cli_search_args_autocompleter')
);