Subversion Repositories eFlore/Applications.cel

Compare Revisions

Ignore whitespace Rev 3130 → Rev 3131

/trunk/jrest/services/CelWidgetExport.php
30,77 → 30,80
require_once 'lib/Spreadsheet/Excel/Writer.php';
 
class CelWidgetExport extends Cel {
 
private $nom_fichier_export = 'cel_export';
// certains paramètres apparaissent plusieurs fois car ils ont des alias
// dans certains widgets
private $parametres_autorises = array(
'id_utilisateur' => 'ce_utilisateur',
'utilisateur' => 'courriel_utilisateur',
'courriel_utilisateur' => 'courriel_utilisateur',
'pays' => 'pays',
'commune' => 'zone_geo',
'zone_geo' => 'zone_geo',
'dept' => 'departement',
'departement' => 'departement',
'lieudit' => 'lieudit',
'station' => 'station',
'projet' => 'mots_cles',
'num_taxon' => 'nt',
'date_debut' => 'date_debut',
'date_fin' => 'date_fin',
'taxon' => 'taxon',
'annee' => 'annee',
'mois' => 'mois',
'jour' => 'jour',
'recherche' => 'recherche',
'id_mots_cles' => 'id_mots_cles',
'mots_cles' => 'mots_cles',
'debut' => 'debut',
'limite' => 'limite',
'format' => 'format',
'colonnes' => 'colonnes',
'transmission' => 'transmission',
'obsids' => 'obsids',
'id_utilisateur' => 'ce_utilisateur',
'utilisateur' => 'courriel_utilisateur',
'courriel_utilisateur' => 'courriel_utilisateur',
'pays' => 'pays',
'commune' => 'zone_geo',
'zone_geo' => 'zone_geo',
'dept' => 'departement',
'departement' => 'departement',
'lieudit' => 'lieudit',
'station' => 'station',
'projet' => 'mots_cles',
'programme' => 'programme',
'num_taxon' => 'nt',
'date_debut' => 'date_debut',
'date_fin' => 'date_fin',
'taxon' => 'taxon',
'identiplante' => 'validation_identiplante',
'validation_identiplante' => 'validation_identiplante',
'annee' => 'annee',
'mois' => 'mois',
'jour' => 'jour',
'recherche' => 'recherche',
'id_mots_cles' => 'id_mots_cles',
'mots_cles' => 'mots_cles',
'debut' => 'debut',
'limite' => 'limite',
'format' => 'format',
'colonnes' => 'colonnes',
'transmission' => 'transmission',
'obsids' => 'obsids',
);
 
private $limite_decoupage_defaut = 9000;
 
private $format = 'csv';
 
public $id_utilisateur = null;
 
public $export_prive = false;
 
// un cache, initialisé par certaines fonctions de préchargement, à la manière
// de ce qui est fait par FormateurGroupeColonne
static $cache = Array();
 
public function getRessource() {
return $this->getElement(array());
}
 
/**
* Méthode appelée avec une requête de type GET.
*/
public function getElement($params = array()) {
switch(@strtolower($params[0])) {
case 'calcul':
$this->getCalcul();
break;
 
case 'export':
$this->getExport();
break;
default:
$this->getExport();
case 'calcul':
$this->getCalcul();
break;
case 'export':
$this->getExport();
break;
default:
$this->getExport();
}
}
 
private function getCalcul() {
$criteres = $this->traiterParametresAutorises($_GET);
$criteres['transmission'] = 1;
 
// Définit si l'on exporte les obs privées ainsi que les champs étendus privés
$this->export_prive = $this->doitEtPeutExporterObsPrivees($criteres);
if($this->export_prive) {
107,23 → 110,22
unset($criteres['transmission']);
$this->id_utilisateur = $criteres['id_utilisateur'];
}
$chercheur_observations = new RechercheObservation($this->config);
 
$chercheur_observations = new RechercheObservationExport($this->config);
$numero_page = isset($criteres['debut']) ? $criteres['debut'] : 0;
$limite = isset($criteres['limite']) ? $criteres['limite'] : 0;
$colonnes = @FormateurGroupeColonne::colGroupsValidation($criteres['colonnes']);
 
unset($criteres['limite']);
unset($criteres['debut']);
unset($criteres['format']);
unset($criteres['colonnes']);
 
$nb_observations = $chercheur_observations->compterObservations(null, $criteres);
$limite_decoupage = $this->calculerNbLignesMaxParFichier(explode(',', $colonnes));
 
$url_telechargements = array();
$intervalle = 0;
 
$params_url = $criteres;
unset($params_url['transmission']);
do {
135,13 → 137,13
$intervalle += $limite_decoupage;
$nb_observations -= $limite_decoupage;
} while($nb_observations > 0);
 
$this->envoyerJson($url_telechargements);
}
 
private function calculerNbLignesMaxParFichier($colonnes) {
$limite = $this->limite_decoupage_defaut;
 
switch($this->format) {
case 'csv':
$limite = 20000;
153,10 → 155,10
$limite = 300;
break;
}
 
return $limite;
}
 
private function getExport() {
$criteres = $this->traiterParametresAutorises($_GET);
// ne pas faire de super-requête en cas d'absence de paramètres
163,75 → 165,75
// par exemple "format", au minimum, devrait être défini
if(!$criteres) die('erreur: pas de paramètre reçu');
if(!in_array($this->format, array('pdf','csv','xls'))) die('erreur: format invalide');
 
$criteres['transmission'] = 1;
//$criteres['transmission'] = 1;
// Définit si l'on exporte les obs privées ainsi que les champs étendus privés
$this->export_prive = $this->doitEtPeutExporterObsPrivees($criteres);
if($this->export_prive) {
unset($criteres['transmission']);
//unset($criteres['transmission']);
$this->id_utilisateur = $criteres['ce_utilisateur'];
}
$chercheur_observations = new RechercheObservation($this->config);
 
$chercheur_observations = new RechercheObservationExport($this->config);
$debut = isset($criteres['debut']) ? intval($criteres['debut']) : 0;
$limite = isset($criteres['limite']) ? intval($criteres['limite']) : 0;
$groupes = @FormateurGroupeColonne::colGroupsValidation($criteres['colonnes']);
$groupes .= ',auteur';
 
if(!$groupes) die('erreur: Ne peut identifier les groupes de champs demandés.');
 
 
if($criteres['obsids']) $criteres['sql_brut'] = sprintf('id_observation IN (%s)',
implode(',', $criteres['obsids']));
 
implode(',', $criteres['obsids']));
unset($criteres['limite']);
unset($criteres['debut']);
unset($criteres['format']);
unset($criteres['colonnes']);
unset($criteres['obsids']);
 
$observations = $chercheur_observations->rechercherObservations(null, $criteres, $debut, $limite, TRUE)->get();
$ids = array();
foreach($observations as &$obs) {
$ids[] = $obs['id_observation'];
}
 
if($this->format == 'pdf') {
$pdf = $this->convertirEnPdf($observations);
$pdf->pdf->Output('etiquettes.pdf', 'I');
exit;
}
 
// cas XLS et CSV: on peut avoir besoin des champs étendus, des noms communs et des champs baseflor:
 
// Obtention des colonnes correspondantes aux groupes de champs
$colonnes = FormateurGroupeColonne::nomEnsembleVersListeColonnes($groupes);
 
/*
Champs étendus et noms communs, si demandés.
* Pour "nom commun", "preload" retourne NULL, car c'est le cache statique de FormateurGroupeColonne
qu'il initialise et utilise en interne sans qu'un passage par paramètre dans le contexte de CelWidgetExport
ne soit nécessaire.
* Pour les champs étendus, c'est CelWidgetExport::$cache qui est utilisé, aussi bien pour les en-têtes que
pour les données préchargées, cf self::traiterLigneEtendue()
*/
Champs étendus et noms communs, si demandés.
* Pour "nom commun", "preload" retourne NULL, car c'est le cache statique de FormateurGroupeColonne
qu'il initialise et utilise en interne sans qu'un passage par paramètre dans le contexte de CelWidgetExport
ne soit nécessaire.
* Pour les champs étendus, c'est CelWidgetExport::$cache qui est utilisé, aussi bien pour les en-têtes que
pour les données préchargées, cf self::traiterLigneEtendue()
*/
self::$cache = FormateurGroupeColonne::preload($colonnes, $this, $ids);
 
// TODO: tous les champs étendus et les paramètres supplémentaires devraient être passés en un seul
// tableau (et chaque formateur csv, xls etc... pourrait également être dans une classe à part)
// TODO: tous les champs étendus et les paramètres supplémentaires devraient être passés en un seul
// tableau (et chaque formateur csv, xls etc... pourrait également être dans une classe à part)
switch($this->format) {
case 'csv':
$csv = $this->convertirEnCsv($observations, $colonnes);
$this->envoyerCsv($csv);
break;
case 'xls':
$xls = $this->convertirEnXls($observations, $colonnes);
$this->envoyerXls($xls);
break;
default:
case 'csv':
$csv = $this->convertirEnCsv($observations, $colonnes);
$this->envoyerCsv($csv);
break;
case 'xls':
$xls = $this->convertirEnXls($observations, $colonnes);
$this->envoyerXls($xls);
break;
default:
}
}
 
protected function traiterParametresAutorises(Array $parametres) {
$parametres_traites = array();
$this->format = (isset($parametres['format']) && $parametres['format'] != '') ? $parametres['format'] : $this->format;
244,7 → 246,7
$parametres_traites['obsids'] = @self::traiterObsIds($parametres['obsids']);
return $parametres_traites;
}
 
private function envoyerCsv($csv) {
header('Content-Type: text/csv; charset=UTF-8');
header('Content-Disposition: attachment;filename='.$this->nom_fichier_export.'.csv');
251,16 → 253,16
echo $csv;
exit;
}
 
private function envoyerXls($workbook) {
$workbook->close();
exit;
}
 
private function convertirEnCsv(&$data, $colonnes) {
$chemin_temp = "php://temp";
$outstream = fopen($chemin_temp, 'r+');
 
$intitule_champs = array_merge(FormateurGroupeColonne::getIntitulesColonnes($colonnes));
// en premier car utilisé génériquement dans getLigneObservation()
if(isset($colonnes['baseflor'])) {
270,7 → 272,7
if(isset($colonnes['etendu'])) {
$intitule_champs = array_merge($intitule_champs, array_values(self::$cache['etendu']['header']));
}
 
// header
fputcsv($outstream, $intitule_champs, ',', '"');
// lignes
284,22 → 286,22
fclose($outstream);
return $csv;
}
 
private function convertirEnXls(&$data, $colonnes) {
$this->extendSpreadsheetProductor = new SpreadsheetProductor();
$this->extendSpreadsheetProductor->initSpreadsheet();
 
$workbook = new Spreadsheet_Excel_Writer();
// avant la définition du titre de la worksheet !
$workbook->setVersion(8);
 
$worksheet = $workbook->addWorksheet('Liste');
$workbook->setTempDir($this->config['cel']['chemin_stockage_temp']);
$worksheet->setInputEncoding('utf-8');
$workbook->send($this->nom_fichier_export.'.xls');
 
$nb_lignes = 1;
 
$intitule_champs = array_merge(FormateurGroupeColonne::getIntitulesColonnes($colonnes));
// en premier car utilisé génériquement dans getLigneObservation()
if(isset($colonnes['baseflor'])) {
309,13 → 311,13
if(isset($colonnes['etendu'])) {
$intitule_champs = array_merge($intitule_champs, array_values(self::$cache['etendu']['header']));
}
 
// header
$indice = 0;
foreach ($intitule_champs as &$intitule) {
$worksheet->write(0,$indice++,$intitule);
}
 
foreach($data as &$ligne) {
$ligne = self::filtrerDonneesSensibles($ligne);
$ligne = FormateurGroupeColonne::getLigneObservation($ligne, $colonnes, $this);
327,7 → 329,7
}
return $workbook;
}
 
private function convertirEnPdf(&$observations) {
if(count($observations) > 300) die('erreur: trop de données');
//require_once('GenerateurPDF.php');
335,7 → 337,7
$pdf->export($observations);
return $pdf;
}
 
static function filtrerDonneesSensibles($ligne) {
if(stripos($ligne['mots_cles_texte'], 'sensible') !== false) {
$ligne['latitude'] = '';
343,18 → 345,18
}
return $ligne;
}
 
private function doitEtPeutExporterObsPrivees($criteres) {
return isset($criteres['ce_utilisateur']) &&
$this->peutExporterObsPrivees($criteres['ce_utilisateur']);
$this->peutExporterObsPrivees($criteres['ce_utilisateur']);
}
 
private function peutExporterObsPrivees($id_utilisateur) {
$gestion_utilisateur = new GestionUtilisateur($this->config);
$utilisateur = $gestion_utilisateur->obtenirIdentiteConnectee();
return ! empty($utilisateur['id_utilisateur']) && $id_utilisateur == $utilisateur['id_utilisateur'];
}
 
static function traiterObsIds($range_param) {
if (!isset($range_param)) return NULL;
// trim() car: `POST http://url<<<"range=*"`
361,7 → 363,7
if (trim($range_param) == '*') return NULL;
return self::rangeToList(trim($range_param));
}
 
/*
* @param $fieldSets: un range, eg: 1-5,8,32,58-101
* @return un tableau trié, eg: 1,2,3,4,5,8,32,58,...,101
370,7 → 372,7
static function rangeToList($in = '') {
$inSets = explode(',', trim($in, ','));
$outSets = array();
 
foreach($inSets as $inSet) {
list($start,$end) = explode('-', $inSet . '-' . $inSet);
// ignore les ranges trop importants
/trunk/jrest/bibliotheque/RechercheObservationExport.php
New file
0,0 → 1,359
<?php
// declare(encoding='UTF-8');
/**
* Classe de recherche d'observations à partir de divers critères.
*
* @internal Mininum PHP version : 5.2
* @category CEL
* @package Services
* @subpackage Bibliothèques
* @version 0.1
* @author Mathias CHOUET <mathias@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @author Aurelien PERONNET <aurelien@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @copyright 1999-2014 Tela Botanica <accueil@tela-botanica.org>
*/
class RechercheObservationExport extends Cel {
 
public $requete_selection_observations;
public static $tris_possibles = array(
'nom_referentiel',
'nom_sel',
'certitude',
'nom_ret',
'famille',
'abondance',
'phenologie',
'ce_zone_geo',
'altitude',
'date_observation'
);
 
 
 
public function rechercherObservations($id_utilisateur = null, $criteres = array(), $debut = 0, $limite = 50, $autoriser_sql_brut = FALSE) {
$requete_selection_observations = 'SELECT * FROM cel_export ';
 
if ($id_utilisateur != null) {
$requete_selection_observations .= 'WHERE ce_utilisateur = '.Cel::db()->proteger($id_utilisateur).' AND ';
} else if(count($criteres) > 0) {
$requete_selection_observations .= 'WHERE ';
}
 
$tri = (isset($criteres['tri']) && in_array($criteres['tri'], self::$tris_possibles)) ? $criteres['tri'] : 'id_observation';
unset($criteres['tri']);
$tri_dir = (isset($criteres['tri_dir']) && in_array($criteres['tri_dir'], array('ASC', 'DESC'))) ? $criteres['tri_dir'] : 'ASC';
unset($criteres['tri_dir']);
 
// très mauvaise solution, mais qui permet au moins d'effectuer des requêtes complexes, sans modifier l'API
// et sans pour autant introduire de problème de sécurité majeur dans toutes les fonctions appelantes qui
// effectue $criteres = $_GET sans nettoyage préalable.
if(isset($criteres['sql_brut']) && !$autoriser_sql_brut) unset($criteres['sql_brut']);
$sous_requete_recherche = $this->fabriquerSousRequeteRecherche($id_utilisateur, $criteres);
 
$requete_selection_observations .= $sous_requete_recherche;
$requete_selection_observations = rtrim($requete_selection_observations, 'AND ');
$requete_selection_observations .= $id_utilisateur == null ? ' ORDER BY id_observation ' : ' ORDER BY '.$tri.' '.$tri_dir;
$requete_selection_observations .= ($debut == 0 && $limite == 0) ? '' : ' LIMIT '.$debut.','.$limite ;
 
$this->requete_selection_observations = $requete_selection_observations;
return $this;
}
 
public function get() {
if (!$this->requete_selection_observations) {
return false;
}
return Cel::db()->requeter($this->requete_selection_observations);
}
 
public function compterObservations($id_utilisateur = null, $criteres = array()) {
$requete = 'SELECT COUNT(*) AS nb_obs FROM cel_export ';
if ($id_utilisateur != null) {
$requete .= 'WHERE ce_utilisateur = '.Cel::db()->proteger($id_utilisateur).' AND ';
} else if(count($criteres) > 0) {
$requete .= 'WHERE ';
}
$requete .= $this->fabriquerSousRequeteRecherche($id_utilisateur, $criteres);
$requete = rtrim($requete, 'AND ');
$resultat = Cel::db()->requeter($requete);
$nb_obs = ($resultat && is_array($resultat) && count($resultat) > 0) ? $resultat[0]['nb_obs'] : '0';
return $nb_obs;
}
 
public function formaterPourEnvoiCel(&$tableau_observations) {
$ids = array();
foreach ($tableau_observations as &$observation) {
$observation['ce_zone_geo'] = $this->convertirCodeZoneGeoVersCodeInsee($observation['ce_zone_geo']);
$ids_mots_cles = $this->getIdsMotsClesObservation($observation['id_observation']);
 
$ids[] = $observation['id_observation'];
$mots_cles_chaine = '';
foreach ($ids_mots_cles as $id_mot_cle) {
$mots_cles_chaine .= $id_mot_cle['id_mot_cle'].';';
}
$mots_cles_chaine = rtrim($mots_cles_chaine,';');
$observation['mots_cles'] = $mots_cles_chaine;
 
foreach ($observation as $champ => $valeur) {
if ($valeur == 'NULL') {
$observation[$champ] = '';
}
}
}
 
$gestion_champs_etendus = new GestionChampsEtendus($this->config, 'obs');
$champs_supp = $gestion_champs_etendus->consulterParLots($ids);
 
foreach ($tableau_observations as &$obs) {
if (isset($champs_supp[$obs['id_observation']])) {
$obs['obs_etendue'] = $champs_supp[$obs['id_observation']];
}
}
return $tableau_observations;
}
 
public function obtenirIdUtilisateurPourIdObs($id_obs) {
$idObsP = Cel::db()->proteger($id_obs);
$requete = 'SELECT ce_utilisateur '.
'FROM cel_obs '.
"WHERE id_observation = $idObsP ".
' -- '.__FILE__.':'.__LINE__;
$utilisateur_id = Cel::db()->requeter($requete);
 
$retour = false;
if (!empty($utilisateur_id) && isset($utilisateur_id[0]['ce_utilisateur'])) {
$retour = $utilisateur_id[0]['ce_utilisateur'];
}
return $retour;
}
 
public function obtenirCourrielUtilisateurPourIdObs($id_obs) {
$id_obs = Cel::db()->proteger($id_obs);
$requete = "SELECT courriel_utilisateur FROM cel_obs WHERE id_observation = $id_obs";
 
$utilisateur_courriel = Cel::db()->requeter($requete . ' -- ' . __FILE__ . ':' . __LINE__);
 
$retour = false;
if (!empty($utilisateur_courriel) && isset($utilisateur_courriel[0]['courriel_utilisateur'])) {
$retour = $utilisateur_courriel[0]['courriel_utilisateur'];
}
return $retour;
}
 
private function getIdsMotsClesObservation($id_observation) {
$requete_selection_mots_cles = 'SELECT DISTINCT id_mot_cle '.
'FROM cel_mots_cles_obs_liaison '.
"WHERE id_element_lie = $id_observation ";
return Cel::db()->requeter($requete_selection_mots_cles);
}
 
// TODO: fonction temporaire
public function parserRequeteCriteres($chaine_criteres) {
$criteres_parses = array();
$criteres = explode('&', $chaine_criteres) ;
foreach ($criteres as &$critere) {
$nom_valeur = explode('=', $critere) ;
if (count($nom_valeur) >= 2) {
$criteres_parses[$nom_valeur[0]] = $nom_valeur[1];
}
}
return $criteres_parses;
}
 
private function fabriquerSousRequeteRecherche($id_utilisateur, $criteres) {
$sous_requete = '';
foreach ($criteres as $nom => $valeur) {
if ($valeur == null || trim($nom) == '' || trim($valeur) == '') {
continue;
}
 
switch ($nom) {
case "mots_cles";
$sous_requete .= $this->creerSousRequeteMotsCles($valeur);
$sous_requete .= ' AND ';
break;
case 'annee':
if ($valeur == "NULL") {
$sous_requete .= "(date_observation IS NULL OR year(date_observation) = 0000)" ;
} else {
$sous_requete .= "(year(date_observation) = ".Cel::db()->proteger($valeur).")" ;
}
$sous_requete .= ' AND ' ;
break;
case 'mois':
if ($valeur == "NULL") {
$sous_requete .= "date_observation IS NULL OR month(date_observation) = 00" ;
} else {
$sous_requete .= "month(date_observation) = ".Cel::db()->proteger($valeur) ;
}
$sous_requete .= ' AND ' ;
break;
case 'jour':
if ($valeur == "NULL") {
$sous_requete .= "date_observation IS NULL OR day(date_observation) = 00" ;
} else {
$sous_requete .= "day(date_observation) = ".Cel::db()->proteger($valeur) ;
}
$sous_requete .= ' AND ' ;
break;
case 'pays':
if ($valeur == "NULL") {
$sous_requete .= "(pays IS NULL OR pays = '')";
} else {
$pays_t = explode(',', $valeur);
foreach($pays_t as &$pays) {
$pays = Cel::db()->proteger($pays);
}
$sous_requete .= '(pays IN ('.implode(',', $pays_t).')) ';
}
$sous_requete .= ' AND ' ;
break;
case 'departement':
if ($valeur == "NULL") {
$sous_requete .= "(ce_zone_geo IS NULL OR ce_zone_geo = '')";
} else {
if (strpos($valeur,',') !== false) {
$dpts = explode(',',$valeur);
$sous_requete .= '(';
foreach($dpts as $dpt) {
$sous_requete .= "ce_zone_geo LIKE ".Cel::db()->proteger('INSEE-C:'.$dpt.'___').' OR ';
}
$sous_requete = rtrim($sous_requete,' OR ').') ';
} else {
$sous_requete .= "(ce_zone_geo LIKE ".Cel::db()->proteger('INSEE-C:'.$valeur.'___').')';
}
}
$sous_requete .= ' AND ' ;
break;
case 'localite':
case 'commune':
if ($valeur == "NULL") {
$sous_requete .= "(zone_geo IS NULL OR zone_geo = '')";
} else {
$sous_requete .= "(zone_geo = ".Cel::db()->proteger($valeur).')';
}
$sous_requete .= ' AND ' ;
break;
case 'id_mots_cles':
$liste_mc = '"'.str_replace(';','","',$valeur).'"';
$tpl_sous_requete = GestionMotsClesChemin::obtenirTemplateRequeteMotsClesIds('obs');
$sous_requete .= 'id_observation IN ('.sprintf($tpl_sous_requete, $liste_mc).')';
$sous_requete .= ' AND ' ;
break;
case 'recherche':
$sous_requete .= $this->fabriquerSousRequeteRechercheGenerale($id_utilisateur, $valeur);
$sous_requete .= ' AND ';
break;
case 'date_debut':
$sous_requete .= 'date_observation >= '.Cel::db()->proteger($this->formaterEnDateMysql($valeur));
$sous_requete .= ' AND ';
break;
case 'date_fin':
$sous_requete .= 'date_observation <= '.Cel::db()->proteger($this->formaterEnDateMysql($valeur));
$sous_requete .= ' AND ';
break;
case 'taxon':
$valeur_protegee = Cel::db()->proteger($valeur."%");
$sous_requete .= "( nom_sel LIKE ".$valeur_protegee." OR".
" nom_ret LIKE ".$valeur_protegee." OR".
" famille LIKE ".$valeur_protegee.
" ) AND ";
break;
case 'sql_brut':
$sous_requete .= $valeur;
$sous_requete .= ' AND ';
break;
default:
if(!preg_match('/^[a-zA-Z0-9_-]+$/', $nom)) break;
$valeur = rtrim($valeur);
// TODO: pour de nombreux champs, et lorsque les webservices d'update/insert
// trim() + NULLify'ront les données vides, alors nous pourrons omettre ce pénible
// double-test pour la plupart des champs
if ($valeur && $valeur != 'NULL') {
$sous_requete .= $nom." = ".Cel::db()->proteger($valeur) ;
$sous_requete .= ' AND ';
}
else {
$sous_requete .= "($nom IS NULL OR $nom = '')";
$sous_requete .= ' AND ';
}
break;
}
}
$sous_requete = rtrim($sous_requete,' AND ');
return $sous_requete;
}
 
private function formaterEnDateMysql($date) {
$annee = substr($date, 6, 4);
$mois = substr($date, 3, 2);
$jour = substr($date, 0, 2);
$date = $annee . '-' . $mois . '-' . $jour;
return $date;
}
 
private function fabriquerSousRequeteRechercheGenerale($id_utilisateur, $valeur) {
$valeur = str_replace('*', '%', $valeur);
$valeur = Cel::db()->proteger("%$valeur%");
$sous_requete = "(nom_sel LIKE $valeur ".
"OR courriel_utilisateur LIKE $valeur ".
"OR prenom_utilisateur LIKE $valeur ".
"OR nom_utilisateur LIKE $valeur ".
"OR nom_sel LIKE $valeur ".
"OR nom_sel_nn LIKE $valeur ".
"OR nom_ret LIKE $valeur ".
"OR nom_ret_nn LIKE $valeur ".
"OR nt LIKE $valeur ".
"OR famille LIKE $valeur ".
"OR zone_geo LIKE $valeur ".
"OR ce_zone_geo LIKE $valeur ".
"OR date_observation LIKE $valeur ".
"OR lieudit LIKE $valeur ".
"OR station LIKE $valeur ".
"OR milieu LIKE $valeur ".
"OR commentaire LIKE $valeur ".
"OR latitude LIKE $valeur ".
"OR longitude LIKE $valeur ".
"OR mots_cles_texte LIKE $valeur ".
")";
return $sous_requete;
}
 
private function creerSousRequeteMotsCles($mot_cle) {
//TODO: une requête plus efficace serait possible en utilisant
// les vraies tables de mots clés et en faisant disparaitre ce champ maudit
$requete = '';
if (preg_match('/.*OU.*/', $mot_cle)) {
$mots_cles_tab = explode('OU',$mot_cle);
foreach($mots_cles_tab as $mot_cle_item) {
$requete .= '(mots_cles_texte LIKE '.Cel::db()->proteger('%'.$mot_cle_item.'%').') OR ';
}
$requete = '('.rtrim($requete,'OR ').')';
} else if (preg_match('/.*ET.*/', $mot_cle)) {
$mots_cles_tab = explode('ET',$mot_cle);
foreach($mots_cles_tab as $mot_cle_item) {
$requete .= '(mots_cles_texte LIKE '.Cel::db()->proteger('%'.$mot_cle_item.'%').') AND ';
}
$requete = '('.rtrim($requete, 'AND ').') ';
} else {
$requete = "(mots_cles_texte LIKE ".Cel::db()->proteger('%'.$mot_cle.'%').') ';
}
return $requete;
}
 
private function estUnvaleurZeroNulle($valeur) {
return $valeur == '000null';
}
 
private function traiterRequeteValeurZeroNulle($valeur) {
$champs = array('annee' => 'date_observation',
'mois' => 'date_observation',
'jour' => 'date_observation',
'departement' => 'ce_zone_geo',
'commune' => 'zone_geo');
return $sous_requete .= $champs[$valeur]." = ".Cel::db()->proteger("");
}
}