source: extensions/GrumPluginClasses/classes/GPCRequestBuilder.class.inc.php @ 17562

Last change on this file since 17562 was 16458, checked in by grum, 12 years ago

feature:2634- compatibility with Piwigo 2.4
Update URI + small changes
File size: 45.1 KB
Line 
1<?php
2/* -----------------------------------------------------------------------------
3  class name: GCPRequestBuilder
4  class version  : 1.1.7
5  plugin version : 3.5.2
6  date           : 2012-06-24
7
8  ------------------------------------------------------------------------------
9  Author     : Grum
10    email    : grum@piwigo.org
11    website  : http://www.grum.fr
12
13    << May the Little SpaceFrog be with you ! >>
14  ------------------------------------------------------------------------------
15  *
16  * theses classes provides base functions to manage search pictures in the
17  * database
18  *
19  *
20  * HOW TO USE IT ?
21  * ===============
22  *
23  * when installing the plugin, you have to register the usage of the request
24  * builder
25  *
26  * 1/ Create a RBCallback class
27  *  - extends the GPCSearchCallback class ; the name of the extended class must
28  *    be "RBCallBack%" => replace the "%" by the plugin name
29  *     for example : 'ThePlugin' => 'RBCallBackThePlugin'
30  *
31  * 2/ In the plugin 'maintain.inc.php' file :
32  *  - function plugin_install, add :
33  *       GPCRequestBuilder::register('plugin name', 'path to the RBCallback classe');
34  *          for example : GPCRequestBuilder::register('ThePlugin', $piwigo_path.'plugins/ThePlugin/rbcallback_file_name.php');
35  *
36  *
37  *  - function plugin_uninstall, add :
38  *       GPCRequestBuilder::unregister('plugin name');
39  *          for example : GPCRequestBuilder::unregister('ThePlugin');
40  *
41  * 3/ In the plugin code, put somewhere
42  *     GPCRequestBuilder::loadJSandCSS();
43  *     => this will load specific JS and CSS in the page, by adding url in the
44  *        the header, so try to put this where you're used to prepare the header
45  *
46  * 4/ to display the request builder, just add the returned string in the html
47  *    page
48  *       $stringForTheTemplate=GPCRequestBuilder::displaySearchPage();
49  *
50  *
51  *
52  * HOW DOES THE REQUEST BUILDER WORKS ?
53  * ====================================
54  *
55  * the request builder works in 2 steps :
56  *  - first step  : build a cache, to associate all image id corresponding to
57  *                  the search criterion
58  *                  the cache is an association of request ID/image id
59  *  - second step : use the cache to retrieve images informations
60  *
61  ------------------------------------------------------------------------------
62  :: HISTORY
63
64| release | date       |
65| 1.0.0   | 2010/04/30 | * start coding
66|         |            |
67| 1.1.0   | 2010/09/08 | * add functionnalities to manage complex requests
68|         |            |
69| 1.1.1   | 2010/10/14 | * fix bug on the buildGroupRequest function
70|         |            |   . adding 'DISTINCT' keyword to the SQL requests
71|         |            |
72|         |            | * ajax management moved into the gpc_ajax.php file
73|         |            |
74|         |            | * fix bug on user level access to picture
75|         |            |
76| 1.1.2   | 2010/11/01 | * mantis bug:1984
77|         |            |   . RBuilder returns an error message when one picture
78|         |            |     have multiple categories
79|         |            |
80| 1.1.3   | 2011/01/31 | * mantis bug:2156
81|         |            |   . undefined variable on RBuilder screens
82|         |            |
83| 1.1.4   | 2011/01/31 | * mantis bug:2167
84|         |            |
85| 1.1.5   | 2011/04/10 | * Compatibility with piwigo 2.2
86|         |            |
87| 1.1.6   | 2011/05/15 | * mantis bug:2302
88|         |            |   . Request builder user interface don't work
89|         |            |
90| 1.1.7   | 2012/06/24 | * use some GPCCore function instead of code
91|         |            |
92|         |            |
93|         |            |
94
95  --------------------------------------------------------------------------- */
96
97if(!defined('GPC_DIR')) define('GPC_DIR' , baseName(dirname(dirname(__FILE__))));
98if(!defined('GPC_PATH')) define('GPC_PATH' , PHPWG_PLUGINS_PATH . GPC_DIR . '/');
99
100include_once('GPCTables.class.inc.php');
101
102/**
103 *
104 * Preparing the temporary table => doCache()
105 * ------------------------------------------
106 * To prepare the cache, the request builder use the following functions :
107 *  - getImageId
108 *  - getFrom
109 *  - getWhere
110 *  - getHaving
111 *
112 * Preparing the cache table => doCache()
113 * --------------------------------------
114 * To prepare the cache, the request builder use the following functions :
115 *  => the getFilter function is used to prepare the filter for the getPage()
116 *     function ; not used to build the cache
117 *
118 * Retrieving the results => getPage()
119 * -----------------------------------
120 * To retrieve the image informations, the request builder uses the following
121 * functions :
122 *  - getSelect
123 *  - getFrom
124 *  - getJoin
125 *  - getFilter (in fact, the result of this function is stored by the doCache()
126 *               function while the cache is builded, but it is used only when
127 *               retrieving the results for multirecord tables)
128 *  - formatData
129 *
130 *
131 * Example
132 * -------
133 * Consider the table "tableA" like this
134 *
135 *  - (*) imageId
136 *  - (*) localId
137 *  -     att1
138 *  -     att2
139 *  The primary key is the 'imageId'+'localId' attributes
140 *    => for one imageId, you can have ZERO or more than ONE record
141 *       when you register the class, you have to set the $multiRecord parameter
142 *       to 'y'
143 *
144 *  gatImageId returns      : "tableA.imageId"
145 *  getSelect returns       : "tableA.att1, tableA.att2"
146 *  getFrom returns         : "tableA"
147 *  getWhere returns        : "tableA.localId= xxxx AND tableA.att1 = zzzz"
148 *  getJoin returns         : "tableA.imageId = pit.id"
149 *  getFilter returns       : "tableA.localId= xxxx"
150 *
151 *  Examples :
152 *   - plugin AdvancedMetadata use getFilter
153 *   - plugin AdvancedSearchEngine, module ASETag use getHaving and getWhere
154 */
155class GPCSearchCallback {
156
157  /**
158   * the getImageId returns the name of the image id attribute
159   * return String
160   */
161  static public function getImageId()
162  {
163    return("");
164  }
165
166  /**
167   * the getSelect function must return an attribute list separated with a comma
168   *
169   * "att1, att2, att3, att4"
170   *
171   * you can specifie tables names and aliases
172   *
173   * "table1.att1 AS alias1, table1.att2 AS alias2, table2.att3 AS alias3"
174   */
175  static public function getSelect($param="")
176  {
177    return("");
178  }
179
180  /**
181   * the getFrom function must return a tables list separated with a comma
182   *
183   * "table1, (table2 left join table3 on table2.key = table3.key), table4"
184   */
185  static public function getFrom($param="")
186  {
187    return("");
188  }
189
190  /**
191   * the getWhere function must return a ready to use where clause
192   *
193   * "(att1 = value0 OR att2 = value1) AND att4 LIKE value2 "
194   */
195  static public function getWhere($param="")
196  {
197    return("");
198  }
199
200
201  /**
202   * the getHaving function return a ready to user HAVING clause
203   *
204   * " FIND_IN_SET(value0, GROUP_CONCAT(DISTINCT att1 SEPARATOR ',')) AND
205   *   FIND_IN_SET(value0, GROUP_CONCAT(DISTINCT att1 SEPARATOR ',')) "
206   *
207   */
208  static public function getHaving($param="")
209  {
210    return("");
211  }
212
213
214  /**
215   * the getJoin function must return a ready to use sql statement allowing to
216   * join the IMAGES table (key : pit.id) with given conditions
217   *
218   * "att3 = pit.id "
219   */
220  static public function getJoin($param="")
221  {
222    return("");
223  }
224
225
226  /**
227   * the getFilter function must return a ready to use where clause
228   * this where clause is used to filter the cache when the used tables can
229   * return more than one result
230   *
231   * the filter can be empty, can be equal to the where clause, or can be equal
232   * to a sub part of the where clause
233   *
234   * in most case, return "" is the best solution
235   *
236   */
237  static public function getFilter($param="")
238  {
239    //return(self::getWhere($param));
240    return("");
241  }
242
243
244  /**
245   * this function is called by the request builder, allowing to display plugin
246   * data with a specific format
247   *
248   * @param Array $attributes : array of ('attribute_name' => 'attribute_value')
249   * @return String : HTML formatted value
250   */
251  static public function formatData($attributes)
252  {
253    return(print_r($attributes, true));
254  }
255
256
257  /**
258   * this function is called by the request builder to make the search page, and
259   * must return the HTML & JS code of the dialogbox used to select criterion
260   *
261   * Notes :
262   *  - the dialogbox is a JS object with a public method 'show'
263   *  - when the method show is called, one parameter is given by the request
264   *    builder ; the parameter is an object defined as this :
265   *      {
266   *        cBuilder: an instance of the criteriaBuilder object used in the page,
267   *      }
268   *
269   *
270   *
271   *
272   * @param String $mode : can take 'admin' or 'public' values, allowing to
273   *                       return different interface if needed
274   * @return String : HTML formatted value
275   */
276  static public function getInterfaceContent($mode='admin')
277  {
278    return("");
279  }
280
281  /**
282   * this function returns the label displayed in the criterion menu
283   *
284   * @return String : label displayed in the criterions menu
285   */
286  static public function getInterfaceLabel()
287  {
288    return(l10n('gpc_rb_unknown_interface'));
289  }
290
291  /**
292   * this function returns the name of the dialog box class
293   *
294   * @return String : name of the dialogbox class
295   */
296  static public function getInterfaceDBClass()
297  {
298    return('');
299  }
300
301
302}
303
304
305//load_language('rbuilder.lang', GPC_PATH);
306
307
308class GPCRequestBuilder {
309
310  static public $pluginName = 'GPCRequestBuilder';
311  static public $version = '1.1.4';
312
313  static private $tables = Array();
314  static protected $tGlobalId=0;
315
316  /**
317   * register a plugin using GPCRequestBuilder
318   *
319   * @param String $pluginName : the plugin name
320   * @param String $fileName : the php filename where the callback function can
321   *                           be found
322   * @return Boolean : true if registering is Ok, otherwise false
323   */
324  static public function register($plugin, $fileName)
325  {
326    $config=Array();
327    if(!GPCCore::loadConfig(self::$pluginName, $config))
328    {
329      $config['registered']=array();
330    }
331
332    $config['registered'][$plugin]=Array(
333      'name' => $plugin,
334      'fileName' => $fileName,
335      'date' => date("Y-m-d H:i:s"),
336      'version' => self::$version
337    );
338    return(GPCCore::saveConfig(self::$pluginName, $config));
339  }
340
341  /**
342   * unregister a plugin using GPCRequestBuilder
343   *
344   * assume that if the plugin was not registerd before, unregistering returns
345   * a true value
346   *
347   * @param String $pluginName : the plugin name
348   * @return Boolean : true if registering is Ok, otherwise false
349   */
350  static public function unregister($plugin)
351  {
352    $config=Array();
353    if(GPCCore::loadConfig(self::$pluginName, $config))
354    {
355      if(array_key_exists('registered', $config))
356      {
357        if(array_key_exists($plugin, $config['registered']))
358        {
359          unset($config['registered'][$plugin]);
360          return(GPCCore::saveConfig(self::$pluginName, $config));
361        }
362      }
363    }
364    // assume if the plugin was not registered before, unregistering it is OK
365    return(true);
366  }
367
368  /**
369   * @return Array : list of registered plugins
370   */
371  static public function getRegistered()
372  {
373    $config=Array();
374    if(GPCCore::loadConfig(self::$pluginName, $config))
375    {
376      if(array_key_exists('registered', $config))
377      {
378        return($config['registered']);
379      }
380    }
381    return(Array());
382  }
383
384
385  /**
386   * initialise the class
387   *
388   * @param String $prefixeTable : the piwigo prefixe used on tables name
389   * @param String $pluginNameFile : the plugin name used for tables name
390   */
391  static public function init($prefixeTable, $pluginNameFile)
392  {
393    $list=Array('request', 'result_cache', 'temp');
394
395    for($i=0;$i<count($list);$i++)
396    {
397      self::$tables[$list[$i]]=$prefixeTable.$pluginNameFile.'_'.$list[$i];
398    }
399  }
400
401  /**
402   * create the tables needed by RequestBuilder (used during the gpc process install)
403   */
404  static public function createTables()
405  {
406    $tablesDef=array(
407"CREATE TABLE `".self::$tables['request']."` (
408  `id` int(10) unsigned NOT NULL auto_increment,
409  `user_id` int(10) unsigned NOT NULL,
410  `date` datetime NOT NULL,
411  `num_items` int(10) unsigned NOT NULL default '0',
412  `execution_time` float unsigned NOT NULL default '0',
413  `connected_plugin` char(255) NOT NULL,
414  `filter` text NOT NULL,
415  `parameters` text NOT NULL,
416  PRIMARY KEY  (`id`)
417)
418CHARACTER SET utf8 COLLATE utf8_general_ci",
419
420"CREATE TABLE `".self::$tables['result_cache']."` (
421  `id` int(10) unsigned NOT NULL,
422  `image_id` int(10) unsigned NOT NULL,
423  PRIMARY KEY  (`id`,`image_id`)
424)
425CHARACTER SET utf8 COLLATE utf8_general_ci",
426
427"CREATE TABLE `".self::$tables['temp']."` (
428  `requestId` char(30) NOT NULL,
429  `imageId` mediumint(8) unsigned NOT NULL,
430  PRIMARY KEY  (`requestId`,`imageId`)
431)
432CHARACTER SET utf8 COLLATE utf8_general_ci",
433  );
434
435    $tablef= new GPCTables(self::$tables);
436    $tablef->create($tablesDef);
437
438    return(true);
439  }
440
441  /**
442   * update the tables needed by RequestBuilder (used during the gpc process
443   * activation)
444   */
445  static public function updateTables($pluginPreviousRelease)
446  {
447    $tablef=new GPCTables(array(self::$tables['temp']));
448
449    switch($pluginPreviousRelease)
450    {
451      case '03.01.00':
452        $tablesCreate=array();
453        $tablesUpdate=array();
454
455        $tablesCreate[]=
456"CREATE TABLE `".self::$tables['temp']."` (
457  `requestId` char(30) NOT NULL,
458  `imageId` mediumint(8) unsigned NOT NULL,
459  PRIMARY KEY  (`requestId`,`imageId`)
460)
461CHARACTER SET utf8 COLLATE utf8_general_ci";
462
463        $tablesUpdate[self::$tables['request']]['filter']=
464"ADD COLUMN  `filter` text NOT NULL default '' ";
465
466
467
468        $tablef->create($tablesCreate);
469        $tablef->updateTablesFields($tablesUpdate);
470        // no break ! need to be updated like the next release
471        // break;
472      case '03.01.01':
473      case '03.02.00':
474      case '03.02.01':
475      case '03.03.00':
476      case '03.03.01':
477        $tablesUpdate=array();
478
479        $tablesUpdate[self::$tables['request']]['parameters']=
480"ADD COLUMN `parameters` TEXT NOT NULL AFTER `filter`";
481
482        $tablef->updateTablesFields($tablesUpdate);
483        // no break ! need to be updated like the next release
484        // break;
485    }
486
487    return(true);
488  }
489
490  /**
491   * delete the tables needed by RequestBuilder
492   */
493  static public function deleteTables()
494  {
495    $tablef= new GPCTables(self::$tables);
496    $tablef->drop();
497    return(true);
498  }
499
500
501  /**
502   * delete the config
503   */
504  static public function deleteConfig()
505  {
506    GPCCore::deleteConfig(self::$pluginName);
507  }
508
509  /**
510   * this function add and handler on the 'loc_end_page_header' to add request
511   * builder JS script & specific CSS on the page
512   *
513   * use it when the displayed page need an access to the criteriaBuilder GUI
514   *
515   */
516  static public function loadJSandCSS()
517  {
518    load_language('rbuilder.lang', GPC_PATH);
519    add_event_handler('loc_begin_page_header', array('GPCRequestBuilder', 'insertJSandCSSFiles'), 9);
520  }
521
522
523  /**
524   * insert JS a CSS file in header
525   *
526   * the function is declared public because it used by the 'loc_begin_page_header'
527   * event callback
528   *
529   * DO NOT USE IT DIRECTLY
530   *
531   */
532  static public function insertJSandCSSFiles()
533  {
534    global $template;
535
536
537    $baseName=basename(dirname(dirname(__FILE__))).'/css/';
538    GPCCore::addHeaderCSS('gpc.rbuilder', 'plugins/'.$baseName.'rbuilder.css', 25);
539
540    //$template->append('head_elements', '<link href="plugins/'.$baseName.'rbuilder.css" type="text/css" rel="stylesheet"/>');
541    if(defined('IN_ADMIN')) GPCCore::addHeaderCSS('gpc.rbuilderT', 'plugins/'.$baseName.'rbuilder_'.$template->get_themeconf('name').'.css', 26);
542    //$template->append('head_elements', '<link href="plugins/'.$baseName.'rbuilder_'.$template->get_themeconf('name').'.css" type="text/css" rel="stylesheet"/>');
543
544
545    $baseName=basename(dirname(dirname(__FILE__))).'/js/';
546    GPCCore::addHeaderJS('jquery', 'themes/default/js/jquery.js');
547    GPCCore::addHeaderJS('jquery.ui', 'themes/default/js/ui/jquery.ui.core.js', array('jquery'));
548    GPCCore::addHeaderJS('jquery.ui.widget', 'themes/default/js/ui/jquery.ui.widget.js', array('jquery.ui'));
549    GPCCore::addHeaderJS('jquery.ui.mouse', 'themes/default/js/ui/jquery.ui.mouse.js', array('jquery.ui.widget'));
550    GPCCore::addHeaderJS('jquery.ui.position', 'themes/default/js/ui/jquery.ui.position.js', array('jquery.ui.widget'));
551    GPCCore::addHeaderJS('jquery.ui.draggable', 'themes/default/js/ui/jquery.ui.draggable.js', array('jquery.ui.widget'));
552    GPCCore::addHeaderJS('jquery.ui.dialog', 'themes/default/js/ui/jquery.ui.dialog.js', array('jquery.ui.widget'));
553    GPCCore::addHeaderJS('jquery.ui.slider', 'themes/default/js/ui/jquery.ui.slider.js', array('jquery.ui.widget'));
554
555    GPCCore::addHeaderJS('gpc.external.inestedsortable', 'plugins/'.$baseName.'external/iNestedSortablePack.js', array('jquery', 'jquery.ui'));
556    GPCCore::addHeaderJS('gpc.rbCriteriaBuilder', 'plugins/'.$baseName.'rbCriteriaBuilder.js', array('gpc.external.inestedsortable'));
557
558    GPCCore::addHeaderContent('js',
559"
560var requestBuilderOptions = {
561      textAND:\"".l10n('gpc_rb_textAND')."\",
562      textOR:\"".l10n('gpc_rb_textOR')."\",
563      textNoCriteria:\"".l10n('There is no criteria ! At least, one criteria is required to do search...')."\",
564      textSomethingWrong:\"".l10n('gpc_something_is_wrong_on_the_server_side')."\",
565      textCaddieUpdated:\"".l10n('gpc_the_caddie_is_updated')."\",
566      helpEdit:\"".l10n('gpc_help_edit_criteria')."\",
567      helpDelete:\"".l10n('gpc_help_delete_criteria')."\",
568      helpMove:\"".l10n('gpc_help_move_criteria')."\",
569      helpSwitchCondition:\"".l10n('gpc_help_switch_condition')."\",
570      ajaxUrl:'plugins/GrumPluginClasses/gpc_ajax.php',
571      token:'".get_pwg_token()."'
572    };
573"
574);
575  }
576
577
578  /**
579   * execute request from the ajax call
580   *
581   * @return String : a ready to use HTML code
582   */
583  static public function executeRequest($ajaxfct)
584  {
585    $result='';
586    switch($ajaxfct)
587    {
588      case 'public.rbuilder.searchExecute':
589        $result=self::doCache();
590        break;
591      case 'public.rbuilder.searchGetPage':
592        $result=self::getPage($_REQUEST['requestNumber'], $_REQUEST['page'], $_REQUEST['numPerPage']);
593        break;
594    }
595    return($result);
596  }
597
598
599  /**
600   * clear the cache table
601   *
602   * @param Boolean $clearAll : if set to true, clear all records without
603   *                            checking timestamp
604   */
605  static public function clearCache($clearAll=false)
606  {
607    if($clearAll)
608    {
609      $sql="DELETE FROM ".self::$tables['result_cache'];
610    }
611    else
612    {
613      $sql="DELETE pgrc FROM ".self::$tables['result_cache']." pgrc
614              LEFT JOIN ".self::$tables['request']." pgr
615                ON pgrc.id = pgr.id
616              WHERE pgr.date < '".date('Y-m-d H:i:s', strtotime("-2 hour"))."'";
617    }
618    pwg_query($sql);
619  }
620
621  /**
622   * prepare the temporary table used for multirecord requests
623   *
624   * @param Integer $requestNumber : id of request
625   * @return String : name of the request key temporary table
626   */
627  static private function prepareTempTable($requestNumber)
628  {
629    //$tableName=call_user_func(Array('RBCallBack'.$plugin, 'getFrom'));
630    //$imageIdName=call_user_func(Array('RBCallBack'.$plugin, 'getImageId'));
631
632    $tempClauses=array();
633    foreach($_REQUEST['extraData'] as $key => $extraData)
634    {
635      $tempClauses[$key]=array(
636        'plugin' => $extraData['owner'],
637        'where' => call_user_func(Array('RBCallBack'.$extraData['owner'], 'getWhere'), $extraData['param']),
638        'having' => call_user_func(Array('RBCallBack'.$extraData['owner'], 'getHaving'), $extraData['param']),
639      );
640    }
641
642    $sql="INSERT INTO ".self::$tables['temp']." ".self::buildGroupRequest($_REQUEST[$_REQUEST['requestName']], $tempClauses, $_REQUEST['operator'], ' AND ', $requestNumber);
643//echo $sql;
644    $result=pwg_query($sql);
645
646    return($requestNumber);
647  }
648
649  /**
650   * clear the temporary table used for multirecord requests
651   *
652   * @param Array $requestNumber : the requestNumber to delete
653   */
654  static private function clearTempTable($requestNumber)
655  {
656    $sql="DELETE FROM ".self::$tables['temp']." WHERE requestId = '$requestNumber';";
657    pwg_query($sql);
658  }
659
660
661  /**
662   * execute a query, and place result in cache
663   *
664   *
665   * @return String : queryNumber;numberOfItems
666   */
667  static private function doCache()
668  {
669    global $user;
670
671    self::clearCache();
672
673    $registeredPlugin=self::getRegistered();
674    $requestNumber=self::getNewRequest($user['id']);
675
676    $build=Array(
677      'SELECT' => 'pit.id',
678      'FROM' => '',
679      'WHERE' => 'pit.level <= '.$user['level'],
680      'GROUPBY' => '',
681      'FILTER' => ''
682    );
683    $tmpBuild=Array(
684      'FROM' => Array(
685        '('.IMAGES_TABLE.' pit LEFT JOIN '.IMAGE_CATEGORY_TABLE.' pic ON pit.id = pic.image_id)' /*JOIN IMAGES & IMAGE_CATEGORY tables*/
686       .'   JOIN '.USER_CACHE_CATEGORIES_TABLE.' pucc ON pucc.cat_id=pic.category_id',  /* IMAGE_CATEGORY & USER_CACHE_CATEGORIES_TABLE tables*/
687
688      ),
689      'WHERE' => Array(),
690      'JOIN' => Array(999=>'pucc.user_id='.$user['id']),
691      'GROUPBY' => Array(
692        'pit.id'
693      ),
694      'FILTER' => Array(),
695    );
696
697    /* build data request for plugins
698     *
699     * Array('Plugin1' =>
700     *          Array(
701     *            criteriaNumber1 => pluginParam1,
702     *            criteriaNumber2 => pluginParam2,
703     *            criteriaNumberN => pluginParamN
704     *          ),
705     *       'Plugin2' =>
706     *          Array(
707     *            criteriaNumber1 => pluginParam1,
708     *            criteriaNumber2 => pluginParam2,
709     *            criteriaNumberN => pluginParamN
710     *          )
711     * )
712     *
713     */
714    $pluginNeeded=Array();
715    $pluginList=Array();
716    $tempName=Array();
717    foreach($_REQUEST['extraData'] as $key => $val)
718    {
719      $pluginNeeded[$val['owner']][$key]=$_REQUEST['extraData'][$key]['param'];
720      $pluginList[$val['owner']]=$val['owner'];
721    }
722
723    /* for each plugin, include the rb callback class file */
724    foreach($pluginList as $val)
725    {
726      if(file_exists($registeredPlugin[$val]['fileName']))
727      {
728        include_once($registeredPlugin[$val]['fileName']);
729      }
730    }
731
732    /* prepare the temp table for the request */
733    self::prepareTempTable($requestNumber);
734    $tmpBuild['FROM'][]=self::$tables['temp'];
735    $tmpBuild['JOIN'][]=self::$tables['temp'].".requestId = '".$requestNumber."'
736                        AND ".self::$tables['temp'].".imageId = pit.id";
737
738    /* for each needed plugin, prepare the filter */
739    foreach($pluginNeeded as $key => $val)
740    {
741      foreach($val as $itemNumber => $param)
742      {
743        $tmpFilter=call_user_func(Array('RBCallBack'.$key, 'getFilter'), $param);
744
745        if(trim($tmpFilter)!="") $tmpBuild['FILTER'][$key][]='('.$tmpFilter.')';
746      }
747    }
748
749
750    /* build FROM
751     *
752     */
753    $build['FROM']=implode(',', $tmpBuild['FROM']);
754    unset($tmpBuild['FROM']);
755
756    /* build WHERE
757     */
758    self::cleanArray($tmpBuild['WHERE']);
759    if(count($tmpBuild['WHERE'])>0)
760    {
761      $build['WHERE']=' ('.self::buildGroup($_REQUEST[$_REQUEST['requestName']], $tmpBuild['WHERE'], $_REQUEST['operator'], ' AND ').') ';
762    }
763    unset($tmpBuild['WHERE']);
764
765
766    /* build FILTER
767     */
768    self::cleanArray($tmpBuild['FILTER']);
769    if(count($tmpBuild['FILTER'])>0)
770    {
771      $tmp=array();
772      foreach($tmpBuild['FILTER'] as $key=>$val)
773      {
774        $tmp[$key]='('.implode(' OR ', $val).')';
775      }
776      $build['FILTER']=' ('.implode(' AND ', $tmp).') ';
777    }
778    unset($tmpBuild['FILTER']);
779
780
781    /* for each plugin, adds jointure with the IMAGE table
782     */
783    self::cleanArray($tmpBuild['JOIN']);
784    if(count($tmpBuild['JOIN'])>0)
785    {
786      if($build['WHERE']!='') $build['WHERE'].=' AND ';
787      $build['WHERE'].=' ('.implode(' AND ', $tmpBuild['JOIN']).') ';
788    }
789    unset($tmpBuild['JOIN']);
790
791    self::cleanArray($tmpBuild['GROUPBY']);
792    if(count($tmpBuild['GROUPBY'])>0)
793    {
794      $build['GROUPBY'].=' '.implode(', ', $tmpBuild['GROUPBY']).' ';
795    }
796    unset($tmpBuild['GROUPBY']);
797
798
799
800    $sql=' FROM '.$build['FROM'];
801    if($build['WHERE']!='')
802    {
803      $sql.=' WHERE '.$build['WHERE'];
804    }
805    if($build['GROUPBY']!='')
806    {
807      $sql.=' GROUP BY '.$build['GROUPBY'];
808    }
809
810    $sql.=" ORDER BY pit.id ";
811
812    $sql="INSERT INTO ".self::$tables['result_cache']." (SELECT DISTINCT $requestNumber, ".$build['SELECT']." $sql)";
813
814//echo $sql;
815    $returned="0;0";
816
817    $result=pwg_query($sql);
818    if($result)
819    {
820      $numberItems=pwg_db_changes($result);
821      self::updateRequest($requestNumber, $numberItems, 0, implode(',', $pluginList), $build['FILTER'], $_REQUEST['extraData']);
822
823      $returned="$requestNumber;".$numberItems;
824    }
825
826    self::clearTempTable($requestNumber);
827
828    return($returned);
829  }
830
831  /**
832   * return a page content. use the cache table to find request result
833   *
834   * @param Integer $requestNumber : the request number (from cache table)
835   * @param Integer $pageNumber : the page to be returned
836   * @param Integer $numPerPage : the number of items returned on a page
837   * @param String $mode : if mode = 'count', the function returns the number of
838   *                       rows ; otherwise, returns rows in a html string
839   * @return String : formatted HTML code
840   */
841  static private function getPage($requestNumber, $pageNumber, $numPerPage)
842  {
843    global $conf, $user;
844    $request=self::getRequest($requestNumber);
845
846    if($request===false)
847    {
848      return("KO");
849    }
850
851    $limitFrom=$numPerPage*($pageNumber-1);
852
853    $pluginNeeded=explode(',', $request['connected_plugin']);
854    $registeredPlugin=self::getRegistered();
855
856    $build=Array(
857      'SELECT' => '',
858      'FROM' => '',
859      'WHERE' => '',
860      'GROUPBY' => '',
861    );
862    $tmpBuild=Array(
863      'SELECT' => Array(
864        'RB_PIT' => "pit.id AS imageId, pit.name AS imageName, pit.path AS imagePath", // from the piwigo's image table
865        'RB_PIC' => "GROUP_CONCAT( pic.category_id SEPARATOR ',') AS imageCategoriesId",     // from the piwigo's image_category table
866        'RB_PCT' => "GROUP_CONCAT( CASE WHEN pct.name IS NULL THEN '' ELSE pct.name END SEPARATOR '#sep#') AS imageCategoriesNames,
867                     GROUP_CONCAT( CASE WHEN pct.permalink IS NULL THEN '' ELSE pct.permalink END SEPARATOR '#sep#') AS imageCategoriesPLink,
868                     GROUP_CONCAT( CASE WHEN pct.dir IS NULL THEN 'V' ELSE 'P' END) AS imageCategoriesDir",   //from the piwigo's categories table
869      ),
870      'FROM' => Array(
871        // join rb result_cache table with piwigo's images table, joined with the piwigo's image_category table, joined with the categories table
872        'RB' => "(((".self::$tables['result_cache']." pgrc
873                  RIGHT JOIN ".IMAGES_TABLE." pit
874                  ON pgrc.image_id = pit.id)
875                    RIGHT JOIN ".IMAGE_CATEGORY_TABLE." pic
876                    ON pit.id = pic.image_id)
877                       RIGHT JOIN ".CATEGORIES_TABLE." pct
878                       ON pct.id = pic.category_id)
879                          RIGHT JOIN ".USER_CACHE_CATEGORIES_TABLE." pucc
880                          ON pucc.cat_id = pic.category_id",
881      ),
882      'WHERE' => Array(
883        'RB' => "pgrc.id=".$requestNumber." AND pucc.user_id=".$user['id'],
884        ),
885      'JOIN' => Array(),
886      'GROUPBY' => Array(
887        'RB' => "pit.id"
888      )
889    );
890
891
892    $extraData=array();
893    foreach($request['parameters'] as $data)
894    {
895      $extraData[$data['owner']]=$data['param'];
896    }
897
898    /* for each needed plugin :
899     *  - include the file
900     *  - call the static public function getFrom, getJoin, getSelect
901     */
902    foreach($pluginNeeded as $key => $val)
903    {
904      if(array_key_exists($val, $registeredPlugin))
905      {
906        if(file_exists($registeredPlugin[$val]['fileName']))
907        {
908          include_once($registeredPlugin[$val]['fileName']);
909
910          $tmp=explode(',', call_user_func(Array('RBCallBack'.$val, 'getSelect'), $extraData[$val]));
911          foreach($tmp as $key2=>$val2)
912          {
913            $tmp[$key2]=self::groupConcatAlias($val2, '#sep#');
914          }
915          $tmpBuild['SELECT'][$val]=implode(',', $tmp);
916          $tmpBuild['FROM'][$val]=call_user_func(Array('RBCallBack'.$val, 'getFrom'), $extraData[$val]);
917          $tmpBuild['JOIN'][$val]=call_user_func(Array('RBCallBack'.$val, 'getJoin'), $extraData[$val]);
918        }
919      }
920    }
921
922    /* build SELECT
923     *
924     */
925    $build['SELECT']=implode(',', $tmpBuild['SELECT']);
926
927    /* build FROM
928     *
929     */
930    $build['FROM']=implode(',', $tmpBuild['FROM']);
931    unset($tmpBuild['FROM']);
932
933
934    /* build WHERE
935     */
936    if($request['filter']!='') $tmpBuild['WHERE'][]=$request['filter'];
937    $build['WHERE']=implode(' AND ', $tmpBuild['WHERE']);
938    unset($tmpBuild['WHERE']);
939
940    /* for each plugin, adds jointure with the IMAGE table
941     */
942    self::cleanArray($tmpBuild['JOIN']);
943    if(count($tmpBuild['JOIN'])>0)
944    {
945      $build['WHERE'].=' AND ('.implode(' AND ', $tmpBuild['JOIN']).') ';
946    }
947    unset($tmpBuild['JOIN']);
948
949    self::cleanArray($tmpBuild['GROUPBY']);
950    if(count($tmpBuild['GROUPBY'])>0)
951    {
952      $build['GROUPBY'].=' '.implode(', ', $tmpBuild['GROUPBY']).' ';
953    }
954    unset($tmpBuild['GROUPBY']);
955
956
957    $imagesList=Array();
958
959    $sql='SELECT DISTINCT '.$build['SELECT']
960        .' FROM '.$build['FROM']
961        .' WHERE '.$build['WHERE']
962        .' GROUP BY '.$build['GROUPBY'];
963
964    $sql.=' ORDER BY pit.id '
965         .' LIMIT '.$limitFrom.', '.$numPerPage;
966
967//echo $sql;
968    $result=pwg_query($sql);
969    if($result)
970    {
971      while($row=pwg_db_fetch_assoc($result))
972      {
973        // affect standard datas
974        $datas['imageThumbnail']=DerivativeImage::thumb_url(array('id'=>$row['imageId'], 'path'=>$row['imagePath']));
975        $datas['imageId']=$row['imageId'];
976        $datas['imagePath']=$row['imagePath'];
977        $datas['imageName']=$row['imageName'];
978
979        $datas['imageCategoriesId']=explode(',', $row['imageCategoriesId']);
980        $datas['imageCategoriesNames']=explode('#sep#', $row['imageCategoriesNames']);
981        $datas['imageCategoriesPLink']=explode('#sep#', $row['imageCategoriesPLink']);
982        $datas['imageCategoriesDir']=explode(',', $row['imageCategoriesDir']);
983
984        $datas['imageCategories']=Array();
985        for($i=0;$i<count($datas['imageCategoriesId']);$i++)
986        {
987          $datas['imageCategories'][]=array(
988            'id' => $datas['imageCategoriesId'][$i],
989            'name' => $datas['imageCategoriesNames'][$i],
990            'dirType' => $datas['imageCategoriesDir'][$i],
991            'pLinks' => $datas['imageCategoriesPLink'][$i],
992            'link'=> make_picture_url(
993                        array(
994                          'image_id' => $datas['imageId'],
995                          'category' => array
996                            (
997                              'id' => $datas['imageCategoriesId'][$i],
998                              'name' => $datas['imageCategoriesNames'][$i],
999                              'permalink' => $datas['imageCategoriesPLink'][$i]
1000                            )
1001                        )
1002                      )
1003          );
1004        }
1005
1006        /* affect datas for each plugin
1007         *
1008         * each plugin have to format the data in an HTML code
1009         *
1010         * so, for each plugin :
1011         *  - look the attributes given in the SELECT clause
1012         *  - for each attributes, associate the returned value of the record
1013         *  - affect in datas an index equals to the plugin pluginName, with returned HTML code ; HTML code is get from a formatData function
1014         *
1015         * Example :
1016         *  plugin ColorStart provide 2 attributes 'csColors' and 'csColorsPct'
1017         *
1018         *  we affect to the $attributes var :
1019         *  $attributes['csColors'] = $row['csColors'];
1020         *  $attributes['csColorsPct'] = $row['csColorsPct'];
1021         *
1022         *  call the ColorStat RB callback formatData with the $attributes => the function return a HTML code ready to use in the template
1023         *
1024         *  affect $datas['ColorStat'] = $the_returned_html_code;
1025         *
1026         *
1027         */
1028        foreach($tmpBuild['SELECT'] as $key => $val)
1029        {
1030          if($key!='RB_PIT' && $key!='RB_PIC' && $key!='RB_PCT')
1031          {
1032            $tmp=explode(',', $val);
1033
1034            $attributes=Array();
1035
1036            foreach($tmp as $key2 => $val2)
1037            {
1038              $name=self::getAttribute($val2);
1039              $attributes[$name]=$row[$name];
1040            }
1041
1042            $datas['plugin'][$key]=call_user_func(Array('RBCallBack'.$key, 'formatData'), $attributes);
1043
1044            unset($tmp);
1045            unset($attributes);
1046          }
1047        }
1048        $imagesList[]=$datas;
1049        unset($datas);
1050      }
1051    }
1052
1053    return(self::toHtml($imagesList));
1054    //return("get page : $requestNumber, $pageNumber, $numPerPage<br>$debug<br>$sql");
1055  }
1056
1057  /**
1058   * remove all empty value from an array
1059   * @param Array a$array : the array to clean
1060   */
1061  static private function cleanArray(&$array)
1062  {
1063    foreach($array as $key => $val)
1064    {
1065      if(is_array($val))
1066      {
1067        self::cleanArray($val);
1068        if(count($val)==0) unset($array[$key]);
1069      }
1070      elseif(trim($val)=='') unset($array[$key]);
1071    }
1072  }
1073
1074  /**
1075   * returns the alias for an attribute
1076   *
1077   *  item1                          => returns item1
1078   *  table1.item1                   => returns item1
1079   *  table1.item1 AS alias1         => returns alias1
1080   *  item1 AS alias1                => returns alias1
1081   *  GROUP_CONCAT( .... ) AS alias1 => returns alias1
1082   *
1083   * @param String $var : value to examine
1084   * @return String : the attribute name
1085   */
1086  static private function getAttribute($val)
1087  {
1088    preg_match('/(?:GROUP_CONCAT\(.*\)|(?:[A-Z0-9_]*)\.)?([A-Z0-9_]*)(?:\s+AS\s+([A-Z0-9_]*))?/i', trim($val), $result);
1089    if(array_key_exists(2, $result))
1090    {
1091      return($result[2]);
1092    }
1093    elseif(array_key_exists(1, $result))
1094    {
1095      return($result[1]);
1096    }
1097    else
1098    {
1099      return($val);
1100    }
1101  }
1102
1103
1104  /**
1105   * returns a a sql statement GROUP_CONCAT for an alias
1106   *
1107   *  item1                  => returns GROUP_CONCAT(item1 SEPARATOR $sep) AS item1
1108   *  table1.item1           => returns GROUP_CONCAT(table1.item1 SEPARATOR $sep) AS item1
1109   *  table1.item1 AS alias1 => returns GROUP_CONCAT(table1.item1 SEPARATOR $sep) AS alias1
1110   *  item1 AS alias1        => returns GROUP_CONCAT(item1 SEPARATOR $sep) AS alias1
1111   *
1112   * @param String $val : value to examine
1113   * @param String $sep : the separator
1114   * @return String : the attribute name
1115   */
1116  static private function groupConcatAlias($val, $sep=',')
1117  {
1118    /*
1119     * table1.item1 AS alias1
1120     *
1121     * $result[3] = alias1
1122     * $result[2] = item1
1123     * $result[1] = table1.item1
1124     */
1125    preg_match('/((?:(?:[A-Z0-9_]*)\.)?([A-Z0-9_]*))(?:\s+AS\s+([A-Z0-9_]*))?/i', trim($val), $result);
1126    if(array_key_exists(3, $result))
1127    {
1128      return("GROUP_CONCAT(DISTINCT ".$result[1]." SEPARATOR '$sep') AS ".$result[3]);
1129    }
1130    elseif(array_key_exists(2, $result))
1131    {
1132      return("GROUP_CONCAT(DISTINCT ".$result[1]." SEPARATOR '$sep') AS ".$result[2]);
1133    }
1134    else
1135    {
1136      return("GROUP_CONCAT(DISTINCT $val SEPARATOR '$sep') AS ".$val);
1137    }
1138  }
1139
1140
1141  /**
1142   * get a new request number and create it in the request table
1143   *
1144   * @param Integer $userId : id of the user
1145   * @return Integer : the new request number, -1 if something wrong appened
1146   */
1147  static private function getNewRequest($userId)
1148  {
1149    $sql="INSERT INTO ".self::$tables['request']." VALUES('', '$userId', '".date('Y-m-d H:i:s')."', 0, 0, '', '', '')";
1150    $result=pwg_query($sql);
1151    if($result)
1152    {
1153      return(pwg_db_insert_id());
1154    }
1155    return(-1);
1156  }
1157
1158  /**
1159   * update request properties
1160   *
1161   * @param Integer $request_id : the id of request to update
1162   * @param Integer $numItems : number of items found in the request
1163   * @param Float $executionTime : time in second to execute the request
1164   * @param String $pluginList : list of used plugins
1165   * @param String $parameters : parameters given for the request
1166   * @return Boolean : true if request was updated, otherwise false
1167   */
1168  static private function updateRequest($requestId, $numItems, $executionTime, $pluginList, $additionalFilter, $parameters)
1169  {
1170    $sql="UPDATE ".self::$tables['request']."
1171            SET num_items = $numItems,
1172                execution_time = $executionTime,
1173                connected_plugin = '$pluginList',
1174                filter = '".mysql_escape_string($additionalFilter)."',
1175                parameters = '".serialize($parameters)."'
1176            WHERE id = $requestId";
1177    $result=pwg_query($sql);
1178    if($result)
1179    {
1180      return(true);
1181    }
1182    return(false);
1183  }
1184
1185  /**
1186   * returns request properties
1187   *
1188   * @param Integer $request_id : the id of request to update
1189   * @return Array : properties for request, false if request doesn't exist
1190   */
1191  static private function getRequest($requestId)
1192  {
1193    $returned=false;
1194    $sql="SELECT user_id, date, num_items, execution_time, connected_plugin, filter, parameters
1195          FROM ".self::$tables['request']."
1196          WHERE id = $requestId";
1197    $result=pwg_query($sql);
1198    if($result)
1199    {
1200      while($row=pwg_db_fetch_assoc($result))
1201      {
1202        if($row['parameters']!='') $row['parameters']=unserialize($row['parameters']);
1203        $returned=$row;
1204      }
1205    }
1206    return($returned);
1207  }
1208
1209
1210  /**
1211   * internal function used by the executeRequest function for single record
1212   * requests
1213   *
1214   * this function is called recursively
1215   *
1216   * @param Array $groupContent :
1217   * @param Array $items :
1218   * @return String : a where clause
1219   */
1220  static private function buildGroup($groupContent, $items, $groups, $operator)
1221  {
1222    $returned=Array();
1223    foreach($groupContent as $key => $val)
1224    {
1225      if(strpos($val['id'], 'iCbGroup')!==false)
1226      {
1227        preg_match('/[0-9]*$/i', $val['id'], $groupNumber);
1228        $returned[]=self::buildGroup($val['children'], $items, $groups, $groups[$groupNumber[0]]);
1229      }
1230      else
1231      {
1232        preg_match('/[0-9]*$/i', $val['id'], $itemNumber);
1233        $returned[]=" (".$items[$itemNumber[0]].") ";
1234      }
1235    }
1236    return('('.implode($operator, $returned).')');
1237  }
1238
1239
1240  /**
1241   * internal function used by the executeRequest function for multi records
1242   * requests
1243   *
1244   * this function is called recursively
1245   *
1246   * @param Array $groupContent :
1247   * @param Array $clausesItems : array with 'where' and 'having' conditions (and 'plugin' for the plugin)
1248   * @param Array $groups : operators of each group
1249   * @param String $operator : 'OR' or 'AND', according with the current group operator
1250   * @param String $requestNumber : the request number
1251   * @return String : part of a SQL request
1252   */
1253  static private function buildGroupRequest($groupContent, $clausesItems, $groups, $operator, $requestNumber)
1254  {
1255    $returnedS='';
1256    $returned=Array();
1257    foreach($groupContent as $key => $val)
1258    {
1259      if(strpos($val['id'], 'iCbGroup')!==false)
1260      {
1261        preg_match('/[0-9]*$/i', $val['id'], $groupNumber);
1262
1263        $groupValue=self::buildGroupRequest($val['children'], $clausesItems, $groups, $groups[$groupNumber[0]], $requestNumber);
1264
1265        if($groupValue!='')
1266          $returned[]=array(
1267            'mode'  => 'group',
1268            'value' => $groupValue
1269          );
1270      }
1271      else
1272      {
1273        preg_match('/[0-9]*$/i', $val['id'], $itemNumber);
1274
1275        $returned[]=array(
1276          'mode'  => 'item',
1277          'plugin' => $clausesItems[$itemNumber[0]]['plugin'],
1278          'valueWhere' => ($clausesItems[$itemNumber[0]]['where']!='')?" (".$clausesItems[$itemNumber[0]]['where'].") ":'',
1279          'valueHaving' => ($clausesItems[$itemNumber[0]]['having'])?" (".$clausesItems[$itemNumber[0]]['having'].") ":'',
1280        );
1281      }
1282    }
1283
1284    if(count($returned)>0)
1285    {
1286      if(strtolower(trim($operator))=='and')
1287      {
1288        $tId=0;
1289        foreach($returned as $key=>$val)
1290        {
1291          if($tId>0) $returnedS.=" JOIN ";
1292
1293          if($val['mode']=='item')
1294          {
1295            $returnedS.="(SELECT DISTINCT ".call_user_func(Array('RBCallBack'.$val['plugin'], 'getImageId'))." AS imageId
1296                          FROM ".call_user_func(Array('RBCallBack'.$val['plugin'], 'getFrom'));
1297            if($val['valueWhere']!='') $returnedS.=" WHERE ".$val['valueWhere'];
1298            if($val['valueHaving']!='')
1299              $returnedS.=" GROUP BY imageId
1300                            HAVING ".$val['valueHaving'];
1301            $returnedS.=") t".self::$tGlobalId." ";
1302          }
1303          else
1304          {
1305            $returnedS.="(".$val['value'].") t".self::$tGlobalId." ";
1306          }
1307
1308          if($tId>0) $returnedS.=" ON t".(self::$tGlobalId-1).".imageId = t".self::$tGlobalId.".imageId ";
1309          $tId++;
1310          self::$tGlobalId++;
1311        }
1312        $returnedS="SELECT DISTINCT '$requestNumber', t".(self::$tGlobalId-$tId).".imageId FROM ".$returnedS;
1313      }
1314      else
1315      {
1316        foreach($returned as $key=>$val)
1317        {
1318          if($returnedS!='') $returnedS.=" UNION DISTINCT ";
1319
1320          if($val['mode']=='item')
1321          {
1322            $returnedS.="SELECT DISTINCT '$requestNumber', t".self::$tGlobalId.".imageId
1323                          FROM (SELECT ".call_user_func(Array('RBCallBack'.$val['plugin'], 'getImageId'))." AS imageId
1324                                FROM ".call_user_func(Array('RBCallBack'.$val['plugin'], 'getFrom'));
1325            if($val['valueWhere']!='') $returnedS.=" WHERE ".$val['valueWhere'];
1326            if($val['valueHaving']!='')
1327              $returnedS.=" GROUP BY imageId
1328                            HAVING ".$val['valueHaving'];
1329            $returnedS.=") t".self::$tGlobalId." ";
1330          }
1331          else
1332          {
1333            $returnedS.="SELECT DISTINCT '$requestNumber', t".self::$tGlobalId.".imageId FROM (".$val['value'].") t".self::$tGlobalId;
1334          }
1335
1336          self::$tGlobalId++;
1337        }
1338      }
1339    }
1340
1341    return($returnedS);
1342  }
1343
1344
1345  /**
1346   * convert a list of images to HTML
1347   *
1348   * @param Array $imagesList : list of images id & associated datas
1349   * @return String : list formatted into HTML code
1350   */
1351  static protected function toHtml($imagesList)
1352  {
1353    global $template;
1354
1355    $template->set_filename('result_items',
1356                dirname(dirname(__FILE__)).'/templates/GPCRequestBuilder_result.tpl');
1357
1358
1359
1360    $template->assign('datas', $imagesList);
1361
1362    return($template->parse('result_items', true));
1363  }
1364
1365
1366  /**
1367   * returns allowed (or not allowed) categories for a user
1368   *
1369   * used the USER_CACHE_TABLE if possible
1370   *
1371   * @param Integer $userId : a valid user Id
1372   * @return String : IN(...), NOT IN(...) or nothing if there is no restriction
1373   *                  for the user
1374   */
1375  public function getUserCategories($userId)
1376  {
1377/*
1378    $returned='';
1379    if($user['forbidden_categories']!='')
1380    {
1381      $returned=Array(
1382        'JOIN' => 'AND ('.IMAGE_CATEGORY.'.category_id NOT IN ('.$user['forbidden_categories'].') ) ',
1383        'FROM' => IMAGE_CATEGORY
1384      );
1385
1386
1387    }
1388    *
1389    *
1390    */
1391  }
1392
1393
1394  /**
1395   * display search page
1396   *
1397   * @param Array $filter : an array of string ; each item is the name of a
1398   *                        registered plugin
1399   *                        if no parameters are given, no filter is applied
1400   *                        otherwise only plugin wich name is given are
1401   *                        accessible
1402   */
1403  static public function displaySearchPage($filter=array())
1404  {
1405    global $template, $lang;
1406
1407    if(is_string($filter)) $filter=array($filter);
1408    $filter=array_flip($filter);
1409
1410    GPCCore::addHeaderJS('jquery.ui', 'themes/default/js/ui/jquery.ui.core.js', array('jquery'));
1411    GPCCore::addHeaderJS('jquery.ui.widget', 'themes/default/js/ui/jquery.ui.widget.js', array('jquery.ui'));
1412    GPCCore::addHeaderJS('jquery.ui.mouse', 'themes/default/js/ui/jquery.ui.mouse.js', array('jquery.ui.widget'));
1413    GPCCore::addHeaderJS('jquery.ui.position', 'themes/default/js/ui/jquery.ui.position.js', array('jquery.ui.widget'));
1414    GPCCore::addHeaderJS('jquery.ui.draggable', 'themes/default/js/ui/jquery.ui.draggable.js', array('jquery.ui.widget'));
1415    GPCCore::addHeaderJS('jquery.ui.dialog', 'themes/default/js/ui/jquery.ui.dialog.js', array('jquery.ui.widget'));
1416    GPCCore::addHeaderJS('jquery.ui.slider', 'themes/default/js/ui/jquery.ui.slider.js', array('jquery.ui.widget'));
1417    GPCCore::addHeaderJS('gpc.pagesNavigator', 'plugins/GrumPluginClasses/js/pagesNavigator.js');
1418    GPCCore::addHeaderJS('gpc.rbSearch', 'plugins/GrumPluginClasses/js/rbSearch.js');
1419
1420    $template->set_filename('gpc_search_page',
1421                dirname(dirname(__FILE__)).'/templates/GPCRequestBuilder_search.tpl');
1422
1423    $registeredPlugin=self::getRegistered();
1424    $dialogBox=Array();
1425    foreach($registeredPlugin as $key=>$val)
1426    {
1427      if(array_key_exists($key, $registeredPlugin) and
1428         (count($filter)==0 or array_key_exists($key, $filter)))
1429      {
1430        if(file_exists($registeredPlugin[$key]['fileName']))
1431        {
1432          include_once($registeredPlugin[$key]['fileName']);
1433
1434          $dialogBox[]=Array(
1435            'handle' => $val['name'].'DB',
1436            'dialogBoxClass' => call_user_func(Array('RBCallBack'.$key, 'getInterfaceDBClass')),
1437            'label' => call_user_func(Array('RBCallBack'.$key, 'getInterfaceLabel')),
1438            'content' => call_user_func(Array('RBCallBack'.$key, 'getInterfaceContent')),
1439          );
1440        }
1441      }
1442    }
1443
1444    $datas=Array(
1445      'dialogBox' => $dialogBox,
1446      'themeName' => defined('IN_ADMIN')?$template->get_themeconf('name'):'',
1447    );
1448
1449    $template->assign('datas', $datas);
1450
1451    return($template->parse('gpc_search_page', true));
1452  } //displaySearchPage
1453
1454}
1455
1456
1457?>
Note: See TracBrowser for help on using the repository browser.