Subversion Repositories eFlore/Applications.coel

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
1497 jpm 1
<?php
2
/**
3
 * Service fournissant des informations sur les collections et les structures répondant aux critères de recherche
1753 mathias 4
 * fournis en paramètre.
1698 raphael 5
 *
1753 mathias 6
 * @author Mathias Chouet
1698 raphael 7
 * @author Raphaël Droz <raphael@tela-botanica.org>
1497 jpm 8
 * @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
9
 * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
10
 * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
1698 raphael 11
 * @copyright 2009, 2013 Tela-Botanica
1497 jpm 12
 */
13
class CoelRecherche extends Coel {
1858 delphine 14
	protected $fromClause = array();
15
	protected $whereClause = array();
16
	protected $joinClause = array();
1497 jpm 17
 
18
	/**
19
	 * Méthode principale appelée avec une requête de type GET.
20
	 * Elle sert d'aiguilleur pour appeller la méthode correspondant au type de recherche passé en paramêtre.
21
	 */
22
	public function getElement($param = array()) {
23
		// Initialisation des variables
24
		$info = array();
1753 mathias 25
		// Nous recherchons le type de requête demandé
1497 jpm 26
		$type = $param[0];
27
		$methode = 'getElement'.$type;
1753 mathias 28
 
1497 jpm 29
		if (method_exists($this, $methode)) {
30
			array_shift($param);
31
			$info = $this->$methode($param);
32
		} else {
33
			$this->messages[] = "Le type de recherche demandé '$type' n'est pas disponible.";
34
		}
35
 
36
		// Envoie sur la sortie standard
1700 raphael 37
		if($this->formatRetour == 'text/plain') {
38
			$this->envoyer($info, 'text/plain', 'utf-8', false);
39
			exit;
40
		}
1497 jpm 41
		$this->envoyer($info);
42
	}
1753 mathias 43
 
44
	/** @deprecated retro-compatibilité */
45
	public function getElementParDefaut($param) {
46
		return $this->getElementCollections($param);
47
	}
48
	/** @deprecated retro-compatibilité */
49
	public function getElementNombre($param) {
50
		return $this->getElementNombreCollections($param);
51
	}
52
 
53
	/**
54
	 * Retourne les collections correspondant aux critères de recherche
1497 jpm 55
	 */
1753 mathias 56
	public function getElementCollections($param) {
1497 jpm 57
		// Pré traitement des paramêtres
1753 mathias 58
		$p = $this->pretraiterParametresUrlCollections($param, $_GET);
1698 raphael 59
 
1753 mathias 60
		// Construction des clauses
1858 delphine 61
		self::construireFromEtWhereCollections($p);
1699 raphael 62
 
1497 jpm 63
		// Construction de la requête
1858 delphine 64
		$champs = "cs_id_structure, cs_ville, cs_nom, cs_code_postal, cs_latitude, cs_longitude, cc_id_collection, cc_nom";
65
		$this->orderby = is_null($this->orderby) ? 'cs_ville ASC, cs_nom ASC, cc_nom ASC' : $this->orderby;
66
		$requete = $this->assemblerRequete($champs);
1698 raphael 67
 
1858 delphine 68
		$info =$this->lancerRequete($requete);
1497 jpm 69
		return $info;
70
	}
1753 mathias 71
 
72
	/**
73
	 * Retourne le nombre de collections correspondant aux critères de recherche
1497 jpm 74
	 */
1753 mathias 75
	public function getElementNombreCollections($param) {
76
 
1497 jpm 77
		// Pré traitement des paramêtres
1753 mathias 78
		$p = $this->pretraiterParametresUrlCollections($param, $_GET);
1497 jpm 79
 
1753 mathias 80
		// Construction des clauses
1858 delphine 81
		self::construireFromEtWhereCollections($p);
1753 mathias 82
 
1497 jpm 83
		// Construction de la requête
1545 jpm 84
		// Il est important de compter le nombre d'association structure-collection différentes pour obtenir le bon nombre
1753 mathias 85
		// @WTF si on compte(*) on a le nombre d'associations structure-collection
86
		// si on compte(cs_id_structure) on a le nombre d'associations structure-collection dont la structure n'est pas null
87
		// en aucun cas on n'a le nombre d'association structure-collection DIFFERENTES, à moins de faire un distinct, ce qui n'est pas le cas ici
88
		// @AMHA on devrait compter(*) car la recherche de collections renvoie même celles qui ont une structure null
1858 delphine 89
		$champs = 'COUNT(*) AS nbre, cc_id_collection ';
90
		$this->orderby = is_null($this->orderby) ? 'cs_ville ASC, cs_nom ASC, cc_nom ASC' : $this->orderby;
91
		$requete = $this->assemblerRequete($champs);
1698 raphael 92
 
1858 delphine 93
		$info = $this->lancerRequeteNombre($requete);
94
 
1753 mathias 95
		return $info;
96
	}
1698 raphael 97
 
1753 mathias 98
	/**
99
	 * Retourne les personnes correspondant aux critères de recherche
100
	 */
101
	public function getElementPersonnes($param) {
1858 delphine 102
		// Pré traitement des paramêtres
103
		$p = $this->pretraiterParametresUrlPersonnes($param, $_GET);
1753 mathias 104
 
1858 delphine 105
		// Construction des clauses
106
		self::construireFromEtWherePersonnes($p);
107
		$champs = 'cp_id_personne, cp_fmt_nom_complet, cp_prenom, cp_nom, cp_truk_nom_autre, cp_adresse_01, cp_ville, cp_naissance_date, cp_deces_date';
108
		$this->orderby = is_null($this->orderby) ? 'cp_nom ASC, cp_prenom ASC' : $this->orderby;
109
		$requete = $this->assemblerRequete($champs);
110
 
111
		$info = $this->lancerRequete($requete);
112
		return $info;
113
	}
114
 
115
	/**
116
	 * Retourne le nombre de personnes correspondant aux critères de recherche
117
	 */
118
	public function getElementNombrePersonnes($param) {
1753 mathias 119
		// Pré traitement des paramêtres
120
		$p = $this->pretraiterParametresUrlPersonnes($param, $_GET);
121
 
122
		// Construction des clauses
1858 delphine 123
		self::construireFromEtWherePersonnes($p);
124
		$this->orderby = is_null($this->orderby) ? 'cp_nom ASC, cp_prenom ASC' : $this->orderby;
125
		$champs = 'count(*) as nbre';
1753 mathias 126
		// Construction de la requête
1858 delphine 127
		$requete = $this->assemblerRequete($champs);
128
		$info = $this->lancerRequeteNombre($requete);
129
		return $info;
130
	}
131
 
132
	/**
133
	 * Retourne les publications correspondant aux critères de recherche
134
	 */
135
	public function getElementPublications($param) {
136
		// Pré traitement des paramêtres
137
		$p = $this->pretraiterParametresUrlPublications($param, $_GET);
138
 
139
		// Construction des clauses
140
		self::construireFromEtWherePublications($p);
141
		$champs = '*';
142
		$this->orderby = is_null($this->orderby) ? 'cpu_fmt_auteur ASC' : $this->orderby;
143
		$requete = $this->assemblerRequete($champs);
144
 
145
		$info = $this->lancerRequete($requete);
146
		return $info;
147
	}
148
 
149
	/**
150
	 * Retourne le nombre de personnes correspondant aux critères de recherche
151
	 */
152
	public function getElementNombrePublications($param) {
153
		// Pré traitement des paramêtres
154
		$p = $this->pretraiterParametresUrlPublications($param, $_GET);
155
 
156
		// Construction des clauses
157
		self::construireFromEtWherePublications($p);
158
		$this->orderby = is_null($this->orderby) ? 'cpu_fmt_auteur ASC' : $this->orderby;
159
		$champs = 'count(*) as nbre';
160
		// Construction de la requête
161
		$requete = $this->assemblerRequete($champs);
162
		$info = $this->lancerRequeteNombre($requete);
163
		return $info;
164
	}
165
 
166
	private function assemblerRequete($champs) {
167
		// Construction de la requête
1753 mathias 168
		$requete = sprintf(
1858 delphine 169
				'SELECT %s %s'
1753 mathias 170
				. ' FROM %s %s'
171
				. ' WHERE %s ORDER BY %s %s -- %s:%d',
1858 delphine 172
 
1753 mathias 173
				$this->distinct ? 'DISTINCT' : '',
1858 delphine 174
				$champs,
175
				implode(',', $this->fromClause),
176
				implode(' ', $this->joinClause),
177
				$this->whereClause ? implode(" AND ", $this->whereClause) : TRUE,
178
				$this->orderby,
1753 mathias 179
				$this->limit != -1 ? "LIMIT {$this->start}, {$this->limit}" : "",
180
				__FILE__,
181
				__LINE__
182
		);
183
		//echo "REQUETE: " . $requete;
184
		//exit;
1858 delphine 185
		return $requete;
186
	}
187
 
188
	private function lancerRequete($requete) {
189
		$info = array();
1497 jpm 190
		// Récupération des résultats
191
		try {
1753 mathias 192
			$donnees = $this->bdd->query($requete)->fetchAll(PDO::FETCH_ASSOC);
193
			if ($donnees === false) {
194
				$this->messages[] = "La requête n'a retourné aucun résultat.";
195
			} else {
196
				$info = $donnees;
197
			}
198
		} catch (PDOException $e) {
199
			$this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage());
200
		}
201
		return $info;
202
	}
1858 delphine 203
 
204
	private function lancerRequeteNombre($requete) {
1753 mathias 205
		$info = array();
206
		// Récupération des résultats
207
		try {
1497 jpm 208
			$donnees = $this->bdd->query($requete)->fetch(PDO::FETCH_ASSOC);
209
			if ($donnees === false) {
1753 mathias 210
				$this->messages[] = "La requête n'a retourné aucun résultat.";
1497 jpm 211
			} else {
212
				$info = $donnees['nbre'];
213
			}
214
		} catch (PDOException $e) {
215
			$this->messages[] = sprintf($this->getTxt('sql_erreur'), $e->getFile(), $e->getLine(), $e->getMessage());
216
		}
217
		return $info;
218
	}
1753 mathias 219
 
220
	// Voici les paramètres qu'il faut passer au service Collections, tous et dans l'ordre (soit une valeur soit '*')
221
	private function pretraiterParametresUrlCollections($param, $qs) {
1700 raphael 222
		$params_passes = array(
223
			'mots' => 'str',
1497 jpm 224
			'sci' => 'bool',
225
			'bot' => 'int',
1753 mathias 226
			'lieu-stockage' => 'str',
1497 jpm 227
			'zg' => 'str',
228
			'p' => 'str',
229
			'pr' => 'int',
1700 raphael 230
			'str-d' => 'frdepliste',
1765 aurelien 231
			'veg' => 'int'
1753 mathias 232
		);
233
		return $this->pretraiterParametresUrl($param, $qs, $params_passes);
234
	}
235
 
236
	// Voici les paramètres qu'il faut passer au service Personnes, tous et dans l'ordre (soit une valeur soit '*')
237
	private function pretraiterParametresUrlPersonnes($param, $qs) {
238
		$params_passes = array(
239
			'nom-famille' => 'str',
240
			'adresse' => 'str',
241
			'date-vivant' => 'int'
242
		);
243
		return $this->pretraiterParametresUrl($param, $qs, $params_passes);
244
	}
1858 delphine 245
 
246
	// Voici les paramètres qu'il faut passer au service Personnes, tous et dans l'ordre (soit une valeur soit '*')
247
	private function pretraiterParametresUrlPublications($param, $qs) {
248
		$params_passes = array(
249
				'titre' => 'str',
250
				'auteur' => 'str',
251
				'mot-cle' => 'str',
252
				'revue' => 'str',
253
				'date' => 'int'
254
		);
255
		return $this->pretraiterParametresUrl($param, $qs, $params_passes);
256
	}
1753 mathias 257
 
258
	private function pretraiterParametresUrl($param, $qs, $params_passes) {
1497 jpm 259
		$p = $this->traiterParametresUrl(array_keys($params_passes), $param, false);
1506 jpm 260
		$this->debug[] = $param;
1497 jpm 261
		foreach ($params_passes as $param_passe => $type) {
262
			if (isset($p[$param_passe])) {
263
				// Suppression des éventuels espaces en début et fin de chaine
264
				$valeur = trim($p[$param_passe]);
265
 
266
				// Type de paramêtre chaine
267
				if ($type == 'str') {
268
					// Suppression des slash
269
					$valeur = stripslashes($valeur);
270
 
271
					// Utilisation d'une recherche de chaîne exacte
272
					if (preg_match('/^"(.*)"$/', $valeur, $match)) {
273
						$valeur = '%'.$match[1].'%';
274
					} else {
275
						// Recherche de mots non liés
276
						$mots = explode(' ', $valeur);
277
						$valeur = '%'.implode ('%', $mots).'%';
278
					}
279
					// Mise en place des quotes pour l'intérogation dans la bdd
280
					$valeur = $this->bdd->quote($valeur);
281
				}
282
				// Type de paramêtre booléen
283
				if ($type == 'bool') {
284
					if (preg_match('/^[0]$/', $valeur)) {
285
						$valeur = false;
286
					} else if (preg_match('/^[1]$/', $valeur)) {
287
						$valeur = true;
288
					} else {
1506 jpm 289
						$this->messages[] = "Le paramêtre '$param_passe' attend une valeur de type 0 ou 1 et non '$valeur'.";
1497 jpm 290
						$valeur = null;
291
					}
292
 
293
				}
294
				// Type de paramêtre entier
295
				if ($type == 'int') {
296
					if (!preg_match('/^(?:[0-9]+,\s*)*[0-9]+$/', $valeur)) {
1506 jpm 297
						$this->messages[] = "Le paramêtre '$param_passe' attend une ou plusieurs valeurs de type entiers ".
1497 jpm 298
							"séparés par des virgules et non '$valeur'.";
299
						$valeur = null;
300
					}
301
				}
1700 raphael 302
 
303
				if ($type == 'frdepliste') {
304
					$valeur = array_filter(explode(',', $valeur), create_function('$val', 'return preg_match("/^(\d+|2A|2B)$/i", $val);'));
305
				}
306
 
1497 jpm 307
				$p[$param_passe] = $valeur;
308
			}
309
		}
1702 raphael 310
 
311
        if(isset($qs['pays'])) {
312
            $p['pays'] = array_filter(explode(',', $qs['pays']), create_function('$val', 'return preg_match("/^[A-Z][A-Z]$/", $val);'));
313
            if(!$p['pays']) unset($p['pays']);
314
        }
315
 
1497 jpm 316
		return $p;
317
	}
1753 mathias 318
 
319
	// construit les clauses FROM et WHERE pour la recherche de collections (#CaptainObvious)
1858 delphine 320
	private function construireFromEtWhereCollections($p) {
321
		$this->fromClause = array('coel_collection');
322
		$this->joinClause = array('LEFT JOIN coel_structure ON (cc_ce_structure = cs_id_structure)');
323
		$this->whereClause = array();
1698 raphael 324
 
325
		// Gestion du from en fonction des paramêtres
1858 delphine 326
		if (isset($p['str-d'])) {// ATTENTION : Remplace $this->fromClause, doit être situé en première position!
327
			$this->fromClause = array('coel_structure');
328
			$this->joinClause = array('LEFT JOIN coel_collection ON (cs_id_structure = cc_ce_structure)');
1698 raphael 329
		}
1497 jpm 330
 
331
		// Construire from et where en fonction des paramêtres
332
		if (isset($p['mots'])) {
1858 delphine 333
			$this->whereClause[] = '(' . implode(' OR ', array(
1698 raphael 334
				"cc_nom LIKE {$p['mots']}",
335
				"cc_truk_nom_alternatif LIKE {$p['mots']}",
336
				"cc_truk_code LIKE {$p['mots']}",
337
				"cc_description LIKE {$p['mots']}",
338
				"cc_description_specialiste LIKE {$p['mots']}",
339
				"cc_historique LIKE {$p['mots']}",
340
				"cs_nom LIKE {$p['mots']}",
341
				"cs_truk_nom_alternatif LIKE {$p['mots']}",
342
				"cs_description LIKE {$p['mots']}",
343
				"cs_adresse_01 LIKE {$p['mots']}",
344
				"cs_ville LIKE {$p['mots']}",
345
				"cs_truk_identifiant_alternatif LIKE {$p['mots']}",
346
				"cs_condition_acces LIKE {$p['mots']}",
347
				"cs_condition_usage LIKE {$p['mots']}",
348
				"cs_truk_telephone LIKE {$p['mots']}",
349
				"cs_courriel LIKE {$p['mots']}",
1730 raphael 350
				"cs_truk_url LIKE {$p['mots']}")) . ')';
1497 jpm 351
		}
1698 raphael 352
 
1497 jpm 353
		if (isset($p['sci'])) {
354
			if ($p['sci'] === true) {
1858 delphine 355
				$this->whereClause[] = 'csv_mark_visite_avec_motif = 1';
1502 jpm 356
			} else if ($p['sci'] === false) {
1858 delphine 357
				$this->whereClause[] = 'csv_mark_acces_ss_motif = 1';
1497 jpm 358
			}
359
		}
360
		if (isset($p['bot'])) {
1858 delphine 361
			$this->whereClause[] = "ccb_ce_truk_type IN ({$p['bot']})";
1497 jpm 362
		}
1753 mathias 363
		if (isset($p['lieu-stockage'])) {
1858 delphine 364
      $this->joinClause[] = 'LEFT JOIN coel_meta_liste_valeur cmlv ON cmlv.cmlv_id_valeur = cs_ce_truk_pays';
365
			$this->whereClause[] = '(' . implode(' OR ', array(
1753 mathias 366
				"cs_adresse_01 LIKE {$p['lieu-stockage']}",
367
				"cs_code_postal LIKE {$p['lieu-stockage']}",
368
				"cs_ville LIKE {$p['lieu-stockage']}",
1759 mathias 369
				"cs_ce_truk_pays LIKE {$p['lieu-stockage']}",
370
				"cmlv.cmlv_nom LIKE {$p['lieu-stockage']}",
1753 mathias 371
			)) . ')';
372
		}
1497 jpm 373
		if (isset($p['zg'])) {
1858 delphine 374
			$this->whereClause[] = "cc_truk_couverture_lieu LIKE {$p['zg']}";
1497 jpm 375
		}
376
		if (isset($p['p'])) {
1858 delphine 377
			$this->whereClause[] = "cp_fmt_nom_complet LIKE {$p['p']}";
1497 jpm 378
		}
379
		if (isset($p['pr'])) {
1858 delphine 380
			$this->whereClause[] = "ccap_id_role IN ({$p['pr']})";
1497 jpm 381
		}
1702 raphael 382
 
383
        // par défaut, spécifier un département restreint à la France
1704 raphael 384
        // TODO: INNER JOIN
1497 jpm 385
		if (isset($p['str-d'])) {
1858 delphine 386
            $this->joinClause[] = 'LEFT JOIN coel_meta_liste_valeur cv ON cv.cmlv_id_valeur = cs_ce_truk_pays';
387
			$this->whereClause[] = "cv.cmlv_abreviation IN ('FR', 'RE', 'YT', 'GP', 'MQ', 'GF', 'NC')";
388
			$this->whereClause[] = sprintf("cs_code_postal REGEXP '^(%s).*'", implode('|', $p['str-d']));
1497 jpm 389
		}
1698 raphael 390
 
1702 raphael 391
		if (isset($p['pays'])) {
1721 raphael 392
            if(array_search('FR', $p['pays']) !== FALSE) $p['pays'] = array_merge($p['pays'], array('RE','YT','GP','MQ','GF','NC'));
1858 delphine 393
            $this->joinClause[] = 'LEFT JOIN coel_meta_liste_valeur cv ON cv.cmlv_id_valeur = cs_ce_truk_pays';
394
			$this->whereClause[] = sprintf('cv.cmlv_abreviation IN ("%s")', implode('","', $p['pays']));
1702 raphael 395
		}
396
 
1506 jpm 397
		if (isset($p['veg'])) {
398
			$veg = explode(',', $p['veg']);
399
			$veg_nbre = count($veg);
400
 
401
			if ($veg_nbre == 1) {
1858 delphine 402
				$this->whereClause[] = "ccb_truk_nature LIKE '%{$p['veg']}%'";
1506 jpm 403
			} else {
404
				$recherche = array();
405
				foreach ($veg as $id) {
406
					$recherche[] = "ccb_truk_nature LIKE '%$id%'";
407
				}
1858 delphine 408
				$this->whereClause[] = '('.implode(' OR ', $recherche).') ';
1506 jpm 409
			}
1581 jpm 410
		}
1506 jpm 411
 
1698 raphael 412
 
1497 jpm 413
		if (isset($p['sci'])) {
1858 delphine 414
			$this->joinClause[] = 'LEFT JOIN coel_structure_valorisation ON (cs_id_structure = csv_id_structure)';
1497 jpm 415
		}
1506 jpm 416
		if (isset($p['bot']) || isset($p['veg'])) {
1858 delphine 417
			$this->joinClause[] = 'LEFT JOIN coel_collection_botanique ON (cc_id_collection = ccb_id_collection)';
1497 jpm 418
		}
419
		if (isset($p['p']) || isset($p['pr'])) {
1858 delphine 420
			$this->joinClause[] = 'LEFT JOIN coel_collection_a_personne ON (cc_id_collection = ccap_id_collection)';
1497 jpm 421
		}
422
		if (isset($p['p'])) {
1858 delphine 423
			$this->joinClause[] = 'LEFT JOIN coel_personne ON (ccap_id_personne = cp_id_personne)';
1497 jpm 424
		}
1702 raphael 425
 
1858 delphine 426
        $this->joinClause = array_unique($this->joinClause);
1753 mathias 427
	}
1702 raphael 428
 
1753 mathias 429
	// construit les clauses FROM et WHERE pour la recherche de personnes (#CaptainObvious)
1858 delphine 430
	private function construireFromEtWherePersonnes($p) {
431
		$this->fromClause = array('coel_personne');
432
		$this->joinClause = array();
433
		$this->whereClause = array();
1753 mathias 434
 
1754 mathias 435
		//"cp_truk_recolte LIKE {$p['adresse']}", // Inclure le lieu de récolte ?
436
 
1753 mathias 437
		if (isset($p['nom-famille'])) {
1858 delphine 438
			$this->whereClause[] = "cp_nom LIKE {$p['nom-famille']}";
1753 mathias 439
		}
440
		if (isset($p['adresse'])) {
1858 delphine 441
      $this->joinClause[] = 'LEFT JOIN coel_meta_liste_valeur cmlv ON cmlv.cmlv_id_valeur = cp_ce_truk_pays';
442
			$this->whereClause[] = '(' . implode(' OR ', array(
1753 mathias 443
				"cp_adresse_01 LIKE {$p['adresse']}",
444
				"cp_code_postal LIKE {$p['adresse']}",
445
				"cp_ville LIKE {$p['adresse']}",
1754 mathias 446
				"cp_ce_truk_pays LIKE {$p['adresse']}",
447
				"cp_naissance_lieu LIKE {$p['adresse']}",
1760 mathias 448
				"cp_deces_lieu LIKE {$p['adresse']}",
449
				"cmlv.cmlv_nom LIKE {$p['adresse']}",
1753 mathias 450
			)) . ')';
451
		}
452
		if (isset($p['date-vivant'])) {
1858 delphine 453
			$this->whereClause[] = "cp_naissance_date <= {$p['date-vivant']}";
454
			$this->whereClause[] = "cp_deces_date >= {$p['date-vivant']}";
455
			$this->whereClause[] = "cp_naissance_date IS NOT NULL";
456
			$this->whereClause[] = "cp_deces_date IS NOT NULL";
457
			//$this->whereClause[] = "(cp_deces_date IS NULL OR cp_deces_date >= {$p['date-vivant']})";
1753 mathias 458
		}
459
 
460
		// pour inclure éventuellement les adresses de la structure
461
		/*if (isset($p['adresse'])) {
1858 delphine 462
			$this->joinClause[] = 'JOIN coel_structure_a_personne ON (cp_id_personne = csap_id_personne)';
463
			$this->joinClause[] = 'JOIN coel_structure ON (cs_id_structure = csap_id_structure)';
1753 mathias 464
		}*/
1858 delphine 465
        $this->joinClause = array_unique($this->joinClause);
1700 raphael 466
	}
1858 delphine 467
 
468
	// construit les clauses FROM et WHERE pour la recherche de publications (#CaptainObvious)
469
	private function construireFromEtWherePublications($p) {
470
		$this->fromClause = array('coel_publication');
471
		$this->joinClause = array();
472
		$this->whereClause = array();
473
 
474
		if (isset($p['titre'])) {
475
			$this->whereClause[] = "cpu_titre LIKE {$p['titre']}";
476
		}
477
		if (isset($p['auteur'])) {
478
			$this->whereClause[] = "cpu_fmt_auteur LIKE {$p['auteur']}";
479
		}
480
		if (isset($p['mot-cle'])) {
481
			$this->whereClause[] = "cpu_resume_mot_cle LIKE {$p['mot-cle']}";
482
		}
483
		if (isset($p['revue'])) {
484
			$this->whereClause[] = "cpu_collection LIKE {$p['revue']}";
485
		}
486
		if (isset($p['date'])) {
487
			$this->whereClause[] = "cpu_date_parution LIKE {$p['date']}";
488
		}
489
 
490
	}
1497 jpm 491
}