eZ Publish 3.9.0 : /kernel/classes/ezsearch.php source

[Sommaire] [Imprimer]
   1  <?php
   2  //
   3  // Definition of eZSearch class
   4  //
   5  // Created on: <25-Jun-2002 10:56:09 bf>
   6  //
   7  // SOFTWARE NAME: eZ publish
   8  // SOFTWARE RELEASE: 3.9.0
   9  // BUILD VERSION: 17785
  10  // COPYRIGHT NOTICE: Copyright (C) 1999-2006 eZ systems AS
  11  // SOFTWARE LICENSE: GNU General Public License v2.0
  12  // NOTICE: >
  13  //   This program is free software; you can redistribute it and/or
  14  //   modify it under the terms of version 2.0  of the GNU General
  15  //   Public License as published by the Free Software Foundation.
  16  //
  17  //   This program is distributed in the hope that it will be useful,
  18  //   but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  //   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  //   GNU General Public License for more details.
  21  //
  22  //   You should have received a copy of version 2.0 of the GNU General
  23  //   Public License along with this program; if not, write to the Free
  24  //   Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  25  //   MA 02110-1301, USA.
  26  //
  27  //
  28  
  29  /*!
  30    \class eZSearch
  31    \ingroup eZKernel
  32    \brief eZSearch handles indexing of objects to the search engine
  33  
  34  */
  35  
  36  include_once ( 'lib/ezutils/classes/ezini.php' );
  37  
  38  class eZSearch
  39  {
  40      /*!
  41      */
  42      function eZSearch()
  43      {
  44  
  45      }
  46  
  47      /*!
  48       \static
  49       Will remove the index from the given object from the search engine
  50      */
  51      function removeObject( $contentObject )
  52      {
  53          $ini =& eZINI::instance();
  54  
  55          $searchEngineString = 'ezsearch';
  56          if ( $ini->hasVariable( 'SearchSettings', 'SearchEngine' ) == true )
  57          {
  58              $searchEngineString = $ini->variable( 'SearchSettings', 'SearchEngine' );
  59          }
  60  
  61          // fetch the correct search engine implementation
  62          include_once( 'kernel/search/plugins/' . strToLower( $searchEngineString ) . '/' . strToLower( $searchEngineString ) . '.php' );
  63          $searchEngine = new $searchEngineString;
  64  
  65          $searchEngine->removeObject( $contentObject );
  66      }
  67  
  68      /*!
  69       \static
  70       Will index the content object to the search engine.
  71      */
  72      function addObject( $contentObject )
  73      {
  74          $ini =& eZINI::instance();
  75  
  76          $searchEngineString = 'ezsearch';
  77          if ( $ini->hasVariable( 'SearchSettings', 'SearchEngine' ) == true )
  78          {
  79              $searchEngineString = $ini->variable( 'SearchSettings', 'SearchEngine' );
  80          }
  81  
  82          // fetch the correct search engine implementation
  83          include_once( 'kernel/search/plugins/' . strToLower( $searchEngineString ) . '/' . strToLower( $searchEngineString ) . '.php' );
  84          $searchEngine = new $searchEngineString;
  85  
  86          $searchEngine->addObject( $contentObject, '/content/view/' /*, $metaData*/ );
  87      }
  88  
  89      /*!
  90       \static
  91       Runs a query to the search engine.
  92      */
  93      function search( $searchText, $params, $searchTypes = array() )
  94      {
  95          $ini =& eZINI::instance();
  96  
  97          $searchEngineString = 'ezsearch';
  98          if ( $ini->hasVariable( 'SearchSettings', 'SearchEngine' ) == true )
  99          {
 100              $searchEngineString = $ini->variable( 'SearchSettings', 'SearchEngine' );
 101          }
 102  
 103          include_once( 'kernel/search/plugins/' . strToLower( $searchEngineString ) . '/' . strToLower( $searchEngineString ) . '.php' );
 104          $searchEngine = new $searchEngineString;
 105  
 106          return $searchEngine->search( $searchText, $params, $searchTypes );
 107      }
 108  
 109      /*!
 110       \static
 111      */
 112      function &normalizeText( $text )
 113      {
 114          $ini =& eZINI::instance();
 115  
 116          $searchEngineString = 'ezsearch';
 117          if ( $ini->hasVariable( 'SearchSettings', 'SearchEngine' ) == true )
 118          {
 119              $searchEngineString = $ini->variable( 'SearchSettings', 'SearchEngine' );
 120          }
 121  
 122          include_once( 'kernel/search/plugins/' . strToLower( $searchEngineString ) . '/' . strToLower( $searchEngineString ) . '.php' );
 123          $searchEngine = new $searchEngineString;
 124          $normalizedText =& $searchEngine->normalizeText( $text );
 125          return $normalizedText;
 126      }
 127  
 128      /*!
 129       \static
 130        returns search parameters in array based on supported search types and post variables
 131       */
 132      function &buildSearchArray()
 133      {
 134          $ini =& eZINI::instance();
 135  
 136          $searchEngineString = 'ezsearch';
 137          if ( $ini->hasVariable( 'SearchSettings', 'SearchEngine' ) == true )
 138          {
 139              $searchEngineString = $ini->variable( 'SearchSettings', 'SearchEngine' );
 140          }
 141  
 142          include_once( 'kernel/search/plugins/' . strToLower( $searchEngineString ) . '/' . strToLower( $searchEngineString ) . '.php' );
 143          $searchEngine = new $searchEngineString;
 144  
 145          // This method was renamed in pre 3.5 trunk
 146          if ( method_exists( $searchEngine, 'supportedSearchTypes' ) )
 147          {
 148              $searchTypesDefinition = $searchEngine->supportedSearchTypes();  // new and correct
 149          }
 150          else
 151          {
 152              $searchTypesDefinition = $searchEngine->suportedSearchTypes();  // deprecated
 153          }
 154  
 155          $searchArray = array();
 156          $andSearchParts = array();
 157  
 158          $http =& eZHTTPTool::instance();
 159  
 160          foreach ( $searchTypesDefinition['types'] as $searchType )
 161          {
 162              $postVariablePrefix = 'Content_search_' . $searchType['type'] . '_' . $searchType['subtype'] . '_';
 163              //print $postVariablePrefix . "\n";
 164              //print_r( $searchType['params'] );
 165              $searchArrayPartForType = array();
 166  
 167              $searchPart = array();
 168              $valuesFetched = false;
 169              $valuesMissing = false;
 170              foreach ( $searchType['params'] as $parameter )
 171              {
 172                  eZDebugSetting::writeDebug( 'kernel-search-ezsearch', $postVariablePrefix . $parameter,
 173                                              'post variable to check' );
 174  
 175                  if ( $http->hasVariable( $postVariablePrefix . $parameter ) )
 176                  {
 177                      $values = $http->variable( $postVariablePrefix . $parameter );
 178                      eZDebugSetting::writeDebug( 'kernel-search-ezsearch', $values, 'fetched values' );
 179  
 180                      foreach ( $values as $i => $value )
 181                      {
 182                          $searchArrayPartForType[$i][$parameter] = $values[$i];
 183                          $valuesFetched = true;
 184                      }
 185                  }
 186                  else
 187                  {
 188                      eZDebugSetting::writeDebug( 'kernel-search-ezsearch', $postVariablePrefix . $parameter,
 189                                                  'post variable does not exist' );
 190                      $valuesMissing = true;
 191                      break;
 192                  }
 193              }
 194  
 195              if ( $valuesFetched == true && $valuesMissing == false )
 196              {
 197                  eZDebugSetting::writeDebug( 'kernel-search-ezsearch', 'adding values to search' );
 198                  foreach ( array_keys( $searchArrayPartForType ) as $key )
 199                  {
 200                      $part =& $searchArrayPartForType[$key];
 201                      $part['type'] = $searchType['type'];
 202                      $part['subtype'] = $searchType['subtype'];
 203  
 204                      if ( $part['type'] == 'attribute' )
 205                      {
 206                          // Remove incomplete search parts from the search.
 207                          // An incomplete search part is for instance an empty text field,
 208                          // or a select box with no selected values.
 209  
 210                          // This functionality has been moved to the search engine.
 211                          // Checking if it is defined in the search engine
 212                          if ( method_exists( $searchEngine, 'isSearchPartIncomplete' ) )
 213                          {
 214                              $removePart = $searchEngine->isSearchPartIncomplete( $part );
 215                          }
 216                          else // for backwards compatibility
 217                          {
 218                              $removePart = false;
 219                              switch ( $part['subtype'] )
 220                              {
 221                                  case 'fulltext':
 222                                  {
 223                                      if ( !isset( $part['value'] ) || $part['value'] == '' )
 224                                          $removePart = true;
 225                                  }
 226                                  break;
 227  
 228                                  case 'patterntext':
 229                                  {
 230                                      if ( !isset( $part['value'] ) || $part['value'] == '' )
 231                                          $removePart = true;
 232                                  }
 233                                  break;
 234  
 235                                  case 'integer':
 236                                  {
 237                                      if ( !isset( $part['value'] ) || $part['value'] == '' )
 238                                          $removePart = true;
 239                                  }
 240                                  break;
 241  
 242                                  case 'integers':
 243                                  {
 244                                      if ( !isset( $part['values'] ) || count( $part['values'] ) == 0 )
 245                                          $removePart = true;
 246                                  }
 247                                  break;
 248  
 249                                  case 'byrange':
 250                                  {
 251                                      if ( !isset( $part['from'] ) || $part['from'] == '' ||
 252                                           !isset( $part['to'] ) || $part['to'] == '' )
 253                                          $removePart = true;
 254                                  }
 255                                  break;
 256  
 257                                  case 'byidentifier':
 258                                  {
 259                                      if ( !isset( $part['value'] ) || $part['value'] == '' )
 260                                          $removePart = true;
 261                                  }
 262                                  break;
 263  
 264                                  case 'byidentifierrange':
 265                                  {
 266                                      if ( !isset( $part['from'] ) || $part['from'] == '' ||
 267                                           !isset( $part['to'] ) || $part['to'] == '' )
 268                                          $removePart = true;
 269                                  }
 270                                  break;
 271  
 272                                  case 'integersbyidentifier':
 273                                  {
 274                                      if ( !isset( $part['values'] ) || count( $part['values'] ) == 0 )
 275                                          $removePart = true;
 276                                  }
 277                                  break;
 278  
 279                                  case 'byarea':
 280                                  {
 281                                      if ( !isset( $part['from'] ) || $part['from'] == '' ||
 282                                           !isset( $part['to'] ) || $part['to'] == '' ||
 283                                           !isset( $part['minvalue'] ) || $part['minvalue'] == '' ||
 284                                           !isset( $part['maxvalue'] ) || $part['maxvalue'] == '' )
 285                                      {
 286                                          $removePart = true;
 287                                      }
 288                                  }
 289                              }
 290                          }
 291  
 292                          if ( $removePart )
 293                          {
 294                              eZDebugSetting::writeDebug( 'kernel-search-ezsearch', $searchArrayPartForType[$key],
 295                                                          'removing incomplete search part' );
 296                              unSet( $searchArrayPartForType[$key] );
 297                          }
 298                      }
 299                  }
 300                  $andSearchParts = array_merge( $andSearchParts, $searchArrayPartForType );
 301              }
 302          }
 303          $generalFilter = array();
 304          foreach ( $searchTypesDefinition['general_filter'] as $searchType )
 305          {
 306  
 307              $postVariablePrefix = 'Content_search_' . $searchType['type'] . '_' . $searchType['subtype'] . '_';
 308  
 309              $searchArrayPartForType = array();
 310  
 311              $searchPart = array();
 312              $valuesFetched = false;
 313              $valuesMissing = false;
 314  
 315              foreach ( $searchType['params'] as $parameter )
 316              {
 317                  $varName = '';
 318                  $paramName = '';
 319                  if ( is_array( $parameter ) )
 320                  {
 321                      $varName = $postVariablePrefix . $parameter['value'];
 322                      $paramName = $parameter['value'];
 323                  }
 324                  else
 325                  {
 326                      $varName = $postVariablePrefix . $parameter;
 327                      $paramName = $parameter;
 328                  }
 329  
 330                  eZDebugSetting::writeDebug( 'kernel-search-ezsearch', $varName,
 331                                              'post variable to check' );
 332  
 333                  if ( $http->hasVariable( $varName ) )
 334                  {
 335                      $values = $http->variable( $varName );
 336                      eZDebugSetting::writeDebug( 'kernel-search-ezsearch', $values, 'fetched values' );
 337                      $searchArrayPartForType[$paramName] = $values;
 338                      $valuesFetched = true;
 339  
 340                  }
 341                  else
 342                  {
 343                      eZDebugSetting::writeDebug( 'kernel-search-ezsearch', $varName,
 344                                                  'post variable does not exist' );
 345                      $valuesMissing = true;
 346                      break;
 347                  }
 348              }
 349  
 350              if ( $valuesFetched == true && $valuesMissing == false )
 351              {
 352                  eZDebugSetting::writeDebug( 'kernel-search-ezsearch', 'adding values to search' );
 353  
 354                  $part =& $searchArrayPartForType;
 355  
 356                  $part['type'] = $searchType['type'];
 357                  $part['subtype'] = $searchType['subtype'];
 358  
 359                  if ( $part['type'] == 'general' )
 360                  {
 361                          // Remove incomplete search parts from the search.
 362                          // An incomplete search part is for instance an empty text field,
 363                          // or a select box with no selected values.
 364                      $removePart = false;
 365                      switch ( $part['subtype'] )
 366                      {
 367                          case 'class':
 368                          {
 369                              if ( !isset( $part['value'] ) ||
 370                                   ( is_array( $part['value'] ) && count( $part['value'] ) == 0 ) ||
 371                                   ( !is_array( $part['value'] ) && $part['value'] == '' ) )
 372                                  $removePart = true;
 373                          }
 374                          break;
 375                          case 'publishdate':
 376                          {
 377                              if ( !isset( $part['value'] ) ||
 378                                   ( is_array( $part['value'] ) && count( $part['value'] ) == 0 ) ||
 379                                   ( !is_array( $part['value'] ) && $part['value'] == '' ) )
 380                                  $removePart = true;
 381                          }
 382                          break;
 383                          case 'subtree':
 384                          {
 385                              if ( !isset( $part['value'] ) ||
 386                                   ( is_array( $part['value'] ) && count( $part['value'] ) == 0 ) ||
 387                                   ( !is_array( $part['value'] ) && $part['value'] == '' ) )
 388  
 389                                  $removePart = true;
 390                          }
 391                          break;
 392                      }
 393  
 394                      if ( $removePart )
 395                      {
 396                          eZDebugSetting::writeDebug( 'kernel-search-ezsearch', $searchArrayPartForType[$key],
 397                                                      'removing incomplete search part' );
 398                          unSet( $searchArrayPartForType[$key] );
 399                          continue;
 400                      }
 401                  }
 402  
 403                  $generalFilter = array_merge( $generalFilter, array( $searchArrayPartForType ) );
 404              }
 405  
 406  
 407          }
 408  
 409          if ( $andSearchParts != null )
 410              $searchArray['and'] =& $andSearchParts;
 411          if ( $generalFilter != null )
 412              $searchArray['general'] =& $generalFilter;
 413  
 414          eZDebugSetting::writeDebug( 'kernel-search-ezsearch', $searchArray, 'search array' );
 415          return $searchArray;
 416      }
 417  
 418      /*!
 419       \static
 420       Tells the current search engine to cleanup up all data.
 421      */
 422      function cleanup()
 423      {
 424          $ini =& eZINI::instance();
 425  
 426          $searchEngineString = 'ezsearch';
 427          if ( $ini->hasVariable( 'SearchSettings', 'SearchEngine' ) == true )
 428          {
 429              $searchEngineString = $ini->variable( 'SearchSettings', 'SearchEngine' );
 430          }
 431  
 432          // fetch the correct search engine implementation
 433          include_once( 'kernel/search/plugins/' . strToLower( $searchEngineString ) . '/' . strToLower( $searchEngineString ) . '.php' );
 434          $searchEngine = new $searchEngineString;
 435  
 436          if ( method_exists( $searchEngine, 'cleanup' ) )
 437          {
 438              $searchEngine->cleanup();
 439          }
 440      }
 441  
 442  }
 443  
 444  ?>
Code source de eZ Publish 3.9.0

/kernel/classes/ -> ezsearch.php (source)
