Subversion Repositories eFlore/Applications.cel

Compare Revisions

Ignore whitespace Rev 3657 → Rev 3656

/trunk/scripts/modules/migration_sauvages/bibliotheque/Dao.php
New file
0,0 → 1,66
<?php
// declare(encoding='UTF-8');
/**
* Contient les requêtes effecturant la migration pour Sauvages.
*
* @category CEL
* @package Scripts
* @subpackage Migration : Sauvages
* @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 Dao extends Bdd {
 
public function obtenirNbObservationsSauvages() {
$requete = 'SELECT COUNT(*) AS nb '.
'FROM cel_obs '.
'WHERE mots_cles_texte LIKE "%sauvages%" '.
' AND mots_cles_texte LIKE "%Projets coopératifs%" '.
' AND mots_cles_texte NOT LIKE "%florileges%" '.
' -- '.__FILE__.' '.__LINE__;
 
$resultat = $this->recuperer($requete);
return $resultat['nb'];
}
 
public function obtenirObservationsSauvages($debut, $limite) {
$requete = 'SELECT * '.
'FROM cel_obs '.
'WHERE mots_cles_texte LIKE "%sauvages%" '.
' AND mots_cles_texte LIKE "%Projets coopératifs%" '.
' AND mots_cles_texte NOT LIKE "%florileges%" '.
"LIMIT $debut, $limite ".
' -- '.__FILE__.' '.__LINE__;
 
$resultat = $this->recupererTous($requete);
return $resultat;
}
 
public function ajouterChampsEtendusParLots($obs_a_champs_etendus) {
$lignes = array();
 
foreach ($obs_a_champs_etendus as $champs_etendus_obs) {
foreach ($champs_etendus_obs as $champ_etendu) {
$id = $this->proteger($champ_etendu['id_observation']);
$cle = $this->proteger($champ_etendu['cle']);
$label = $this->proteger($champ_etendu['label']);
$valeur = $this->proteger($champ_etendu['valeur']);
$lignes[] = "($id, $cle, $label, $valeur)";
}
}
 
$requete = "INSERT INTO cel_obs_etendues (id_observation, cle, label, valeur) ".
'VALUES '.implode(',', $lignes).' '.
'ON DUPLICATE KEY UPDATE valeur = VALUES(valeur) '.
'-- '.__FILE__.' '.__LINE__;
 
// la partie on duplicate key est spécifique mysql mais il sera facile de s'en passer le jour
// où l'on change de sgbd
$ajout = $this->requeter($requete);
return ($ajout !== false);
}
}
/trunk/scripts/modules/migration_sauvages/MigrationSauvages.php
New file
0,0 → 1,226
<?php
// declare(encoding='UTF-8');
/**
* Traitement des observations sauvages pour les migrer vers des champs étendus
*
* Description : classe permettant d'affecter des champs étendus aux observations sauvages. Elle permet aussi
* d'exporter les données à migrer en CSV pour vérifier les informations avant la migration.
* Utilisation :
* - Pour migrer : <code>/opt/lamp/bin/php cli.php migration_sauvages -a migrer -v 3</code>
* - Pour exporter : <code>/opt/lamp/bin/php cli.php migration_sauvages -a exporter -s chemin_vers_fichier_sortie</code>
*
* @category CEL
* @package Scripts
* @subpackage Migration : Sauvages
* @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>
*/
include_once dirname(__FILE__).'/bibliotheque/Dao.php';
 
class MigrationSauvages extends Script {
protected $parametres_autorises = array(
'-s' => array(false, true, "Chemin vers le fichier de sortie pour l'export"));
 
 
public function executer() {
$this->dao = new Dao();
// Récupération de paramétres
// Lancement de l'action demandée
$this->mode_verbeux = $this->getParametre('v');
$cmd = $this->getParametre('a');
try {
switch ($cmd) {
case 'exporter' :
$this->exporterObservationsSauvagesAMigrer();
break;
case 'migrer' :
$this->migrerObservationsSauvages();
break;
default :
$msg = "Erreur : la commande '$cmd' n'existe pas!\n".
"Commandes existantes : exporter, migrer";
throw new Exception($msg);
}
} catch (Exception $e) {
$this->traiterErreur($e->getMessage());
}
}
 
private function exporterObservationsSauvagesAMigrer() {
$total = $this->dao->obtenirNbObservationsSauvages();
$pas_liste_obs = 5000;
echo " Traitement des $total observations par paquet de $pas_liste_obs \n";
 
$fichier = $this->getParametre('s');
 
$fp = fopen($fichier, 'w');
$ecrireEntete = true;
for ($i = 0; $i <= $total; $i += $pas_liste_obs) {
$liste_observations = $this->dao->obtenirObservationsSauvages($i, $pas_liste_obs);
foreach ($liste_observations as $observation) {
if ($this->doitMigrerObservation($observation)) {
$champs_etendus = $this->convertirChampsObsSauvagesEnChampsEtendus($observation);
$champs_etendus_fixes = array(
'latitudeDebutRue', 'longitudeDebutRue', 'latitudeFinRue', 'longitudeFinRue',
'adresse', 'coteRue');
foreach ($champs_etendus_fixes as $cle) {
$observation[$cle] = '';
foreach ($champs_etendus as $champs) {
if ($champs['cle'] == $cle) {
$observation[$cle] = $champs['valeur'];
}
}
}
}
if ($ecrireEntete) {
fputcsv($fp, array_keys($observation));
$ecrireEntete = false;
}
fputcsv($fp, array_values($observation));
$this->afficherAvancement("\tObs traitées : ", 1);
}
}
fclose($fp);
echo "\nFin de l'export\n";
}
 
private function migrerObservationsSauvages() {
if ($this->mode_verbeux) $debut = microtime(true);
$nb_obs_modifiees = 0;
$nb_obs_ignorees = 0;
$total = $this->dao->obtenirNbObservationsSauvages();
 
if ($this->mode_verbeux) {
echo "-------------------------------------------------------------------\n".
" Début de la migration des observations sauvages vers les champs étendus \n".
" $total observations concernées\n".
"-------------------------------------------------------------------\n";
}
 
$champs_etendus_a_inserer = array();
$nb_champs_total = 0;
$nb_champs_etendus_a_inserer = 0;
 
$pas_liste_obs = 5000;
echo " Traitement des observations par paquet de ".$pas_liste_obs." (5 champs étendus ajoutés par observation traitée) \n";
 
for ($i = 0; $i <= $total; $i += $pas_liste_obs) {
$liste_observations = $this->dao->obtenirObservationsSauvages($i, $pas_liste_obs);
$champs_etendus_a_inserer = array();
$nb_champs_etendus_a_inserer = 0;
foreach ($liste_observations as $observation) {
 
// test si obs candidate est ok, i.e. si elle contient bien un champ station formate comme ceci
// coordonnees_debut_de_rue;coordonnees_fin_de_rue;cote_de_la_rue
if ($this->doitMigrerObservation($observation)) {
$champs_etendus = $this->convertirChampsObsSauvagesEnChampsEtendus($observation);
$champs_etendus_a_inserer[] = $champs_etendus;
$nb_champs = count($champs_etendus);
$nb_obs_modifiees++;
$nb_champs_etendus_a_inserer += $nb_champs;
$nb_champs_total += $nb_champs;
} else {
$nb_obs_ignorees++;
}
 
// insertion par paquets de 100 champs ou bien à la fin du parcours de la liste s'il y a moins de
// 20 observations à traiter (20 obs * 5 champs = 100 champs)
if ($nb_champs_etendus_a_inserer >= 100) {
$this->dao->ajouterChampsEtendusParLots($champs_etendus_a_inserer);
$champs_etendus_a_inserer = array();
$nb_champs_etendus_a_inserer = 0;
}
}
echo " $nb_champs_total champs étendus insérés \n";
}
 
// insertion des champs restants s'il en reste moins de 100 à la fin
if ($nb_champs_etendus_a_inserer > 0) {
$this->dao->ajouterChampsEtendusParLots($champs_etendus_a_inserer);
$nb_champs_total += $nb_champs_etendus_a_inserer;
echo " $nb_champs_total champs étendus insérés \n";
}
 
if ($this->mode_verbeux) {
$fin = microtime(true);
$tps_ecoule = $fin - $debut;
echo "\n".
"-------------------------------------------------------------------\n".
" Fin de la migration des observations sauvages, \n".
" $tps_ecoule secondes écoulées \n".
" $nb_champs_total champs étendus créées \n".
" $nb_obs_modifiees observations modifiées \n".
" $nb_obs_ignorees observations ignorées \n".
"-------------------------------------------------------------------\n\n";
}
}
 
private function doitMigrerObservation($observation) {
return (!empty($observation['station']) && substr_count($observation['station'], ';') == 2);
}
 
private function convertirChampsObsSauvagesEnChampsEtendus($observation) {
list($coords_debut_rue, $coords_fin_rue, $cote_rue) = explode(';', $observation['station']);
$coords_debut_rue = explode(',', $coords_debut_rue);
$coords_fin_rue = explode(',', $coords_fin_rue);
$lieu_dit = (trim($observation['lieudit']) == 'non renseigné(e)') ? '' : $observation['lieudit'];
$id = $observation['id_observation'];
 
if (!preg_match('/^(?:2cotes|pair|impair|)$/', $cote_rue)) {
$msg = "Obs #$id: erreur champ cote_rue contient : $cote_rue";
$this->traiterErreur($msg);
}
$testCoords = array(
'latitudeDebutRue' => $coords_debut_rue[0],
'longitudeDebutRue' => $coords_debut_rue[1],
'latitudeDebutRue' => $coords_fin_rue[0],
'longitudeDebutRue' => $coords_fin_rue[1]
);
foreach ($testCoords as $champ => $coord) {
if (!preg_match('/^(?:-|)[0-9]{1,2}[.][0-9]{5}$/', $coord)) {
$msg = "Obs #$id: erreur champ $champ contient : $coord";
$this->traiterErreur($msg);
}
}
 
$champs_etendus = array();
if (count($coords_debut_rue) == 2) {
$champs_etendus[] = array('id_observation' => $id,
'cle' => 'latitudeDebutRue',
'label' => 'Latitude du début de la rue',
'valeur' => $coords_debut_rue[0]);
$champs_etendus[] = array('id_observation' => $id,
'cle' => 'longitudeDebutRue',
'label' => 'Longitude du début de la rue',
'valeur' => $coords_debut_rue[1]);
}
if (count($coords_fin_rue) == 2) {
$champs_etendus[] = array('id_observation' => $id,
'cle' => 'latitudeFinRue',
'label' => 'Latitude de fin de la rue',
'valeur' => $coords_fin_rue[0]);
$champs_etendus[] = array('id_observation' => $id,
'cle' => 'longitudeFinRue',
'label' => 'Longitude de fin de la rue',
'valeur' => $coords_fin_rue[1]);
}
if ($lieu_dit != '') {
$champs_etendus[] = array('id_observation' => $id,
'cle' => 'adresse',
'label' => 'Adresse',
'valeur' => $lieu_dit);
}
if (preg_match('/^(?:2cotes|pair|impair)$/', $cote_rue)) {
$champs_etendus[] = array('id_observation' => $id,
'cle' => 'coteRue',
'label' => 'Côté rue',
'valeur' => $cote_rue);
}
 
return $champs_etendus;
}
}
/trunk/scripts/modules/migration_optimisation/MajOptimisation.php
New file
0,0 → 1,44
<?php
// declare(encoding='UTF-8');
/**
* Réalise la mise à jour de la base de données vis à vis du travail d'optimisation.
*
* @category CEL
* @package Scripts
* @subpackage Migration : Optimisation
* @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 MajOptimisation {
 
private $conteneur;
private $bdd;
 
public function __construct($conteneur) {
$this->conteneur = $conteneur;
$this->bdd = $this->conteneur->getBdd();
}
 
public function executer() {
$fichierSql = '../doc/bdd/2014-09_migration_optimisation/maj_optimisation.sql';
$contenuSql = FichierUtil::recupererContenu($fichierSql);
$this->executerScripSql($contenuSql);
}
 
private function executerScripSql($sql) {
$requetes = SqlUtil::extraireRequetes($sql);
$nbreRequetes = count($requetes);
foreach ($requetes as $index => $requete) {
$num = $index + 1;
echo "Exécution de la requete $num/$nbreRequetes :\n $requete\n\n";
$retour = $this->bdd->executer($requete);
if ($retour === false) {
throw new Exception("Un problème est survenu avec la requête $requete\n");
}
}
}
}
/trunk/scripts/modules/migration_optimisation/MigrationOptimisation.php
New file
0,0 → 1,51
<?php
// declare(encoding='UTF-8');
/**
* Mise à jour de la base de données afin de l'optimiser :
* - remplacement du champ "eflore_publiable" de la table "cel_images" par un champ "transmission" (correspondant au champ tansmission des obs)
* - ajout du champ "date_liaison" dans la table "cel_images"
* - ajout du champ "ce_observation" dans la table "cel_images"
* - migration des données de la table cel_obs_images dans cel_images
* - création d'un index sur cel_images.ce_observation
* - suppression de la table cel_obs_images
*
* Utilisation :
* - mise à jour de la bdd : <code>/opt/lamp/bin/php cli.php migration_optimisation -a migrer</code>
*
* @category CEL
* @package Scripts
* @subpackage Migration : Optimisation
* @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 MigrationOptimisation extends CelScript {
 
public function executer() {
try {
$this->initialiserProjet('migration_optimisation');
 
// Lancement de l'action demandée
$cmd = $this->getParametre('a');
switch ($cmd) {
case 'maj' :
$script = $this->chargerClasse('MajOptimisation');
$script->executer();
break;
default :
throw new Exception("Erreur : la commande '$cmd' n'existe pas!");
}
} catch (Exception $e) {
$this->traiterErreur($e->getMessage());
}
}
 
private function chargerClasse($classe) {
require_once $classe.'.php';
$conteneur = new Conteneur($this->parametres);
return new $classe($conteneur);
}
}
/trunk/scripts/modules/migration_mots_cles/MigrationMotsCles.php
New file
0,0 → 1,171
<?php
// declare(encoding='UTF-8');
/**
* Traitement des mots clés cel pour les migrer vers des mots clés stockés avec path enumeration
*
* Utilisation :
* - migrer les mots-clés obs : <code>/opt/lamp/bin/php cli.php migration_mots_cles -a obs</code>
* - migrer les mots-clés images : <code>/opt/lamp/bin/php cli.php migration_mots_cles -a images</code>
*
* @category CEL
* @package Scripts
* @subpackage Migration : Mots-Clés
* @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>
*/
include_once dirname(__FILE__).'/bibliotheque/Dao.php';
 
class MigrationMotsCles extends Script {
 
private $mode;
 
public function executer() {
$cmd = $this->getParametre('a');
$this->mode_verbeux = $this->getParametre('v');
 
switch($cmd) {
case 'obs':
$this->mode = $cmd;
$this->migrerMotsClesObservations();
break;
case 'images':
$this->mode = $cmd;
$this->migrerMotsClesImages();
break;
default:
echo 'Méthode inconnue, les méthodes possibles sont obs et images'."\n";
}
}
 
private function migrerMotsClesObservations() {
$this->dao = new Dao('obs');
$this->convertirNestedSetVersPathEnum();
}
 
private function migrerMotsClesImages() {
$this->dao = new Dao('images');
$this->convertirNestedSetVersPathEnum();
}
 
private function convertirNestedSetVersPathEnum() {
$debut = microtime();
 
$this->dao->viderTables();
 
$mots_cles_hierarchiques = $this->dao->obtenirMotsClesOriginaux($this->mode);
$mots_cles_hierarchiques = $this->formaterChemin($mots_cles_hierarchiques);
 
$liaisons = $this->dao->obtenirLiaisonsMotsClesOriginaux($this->mode);
 
if ($this->mode_verbeux) {
echo "-------------------------------------------------------------------\n";
echo " Début de la migration des mots clés ".$this->mode." \n";
echo " ".count($mots_cles_hierarchiques)." mots clés et ".count($liaisons)." liaisons à migrer \n";
echo "-------------------------------------------------------------------\n";
}
 
$nb_mots_cles = 0;
$nb_liaisons = 0;
 
$mots_cles_slice = array_chunk($mots_cles_hierarchiques, 800, true);
echo " Insertion des mots clés par paquet de 800 \n";
foreach ($mots_cles_slice as &$mots_cles_tranche) {
$this->dao->insererMotsCles($mots_cles_tranche);
$nb_mots_cles += 800;
if($this->mode_verbeux) {
$this->afficherAvancement(' mots clés insérés ', $nb_mots_cles);
}
}
echo "\n Insertion des mots clés ".$this->mode." terminée \n";
 
$infos_nouveaux_mots_cles = $this->dao->obtenirInfosNouveauxMotsCles();
$correspondances = $this->formaterCorrespondanceCheminId($infos_nouveaux_mots_cles);
 
$liaisons_slice = array_chunk($liaisons, 800, true);
echo " Insertion des mots liaisons par paquet de 800 \n";
foreach ($liaisons_slice as &$liaison_tranche) {
$this->dao->insererLiaisonsMotsCles($mots_cles_hierarchiques, $liaison_tranche, $correspondances);
$nb_liaisons += 800;
if($this->mode_verbeux) {
$this->afficherAvancement(' liaisons insérées ', $nb_liaisons);
}
}
echo "\n Insertion des liaisons ".$this->mode." terminée \n";
 
$fin = microtime(true);
if ($this->mode_verbeux) {
echo "\n";
echo "-------------------------------------------------------------------\n";
echo " Fin de la migration des mots clés ".$this->mode.", \n";
echo " ".($fin - $debut)." secondes écoulées \n";
echo " ".count($mots_cles_hierarchiques)." mots clés insérés \n";
echo " ".count($liaisons)." liaisons insérées \n";
echo "-------------------------------------------------------------------\n";
echo "\n";
}
}
 
private function formaterCorrespondanceCheminId($infos_nouveaux_mots_cles) {
$mots_cles_correspondances = array();
foreach ($infos_nouveaux_mots_cles as &$mot) {
$cle = $mot['chemin'].'-'.$mot['id_utilisateur'];
$mots_cles_correspondances[$cle] = $mot;
}
return $mots_cles_correspondances;
}
 
private function formaterChemin($mots_cles) {
$mots_cles_hierarchiques = array();
$chemin_traites = array();
$pbs = array('doublons' => array(), 'vides' => array());
 
foreach ($mots_cles as &$mot) {
 
if (trim($mot['mot_cle']) != "") {
$chemin = '/';
$cle_parent = $mot['parent'].'-'.$mot['id_utilisateur'];
if (isset($mots_cles_hierarchiques[$cle_parent])) {
$chemin = $mots_cles_hierarchiques[$cle_parent]['chemin'];
}
$chemin .= self::simplifier($mot['mot_cle']).'/';
$chemin = str_replace("//", "/", $chemin);
 
if (!isset($chemin_traites[self::harmoniserPourDoublon($chemin).'-'.$mot['id_utilisateur']])) {
$cle = $mot['id_mot_cle'].'-'.$mot['id_utilisateur'];
 
$mots_cles_hierarchiques[$cle] = array(
'id_utilisateur' => $mot['id_utilisateur'],
'chemin' => $chemin,
'mot_cle' => $mot['mot_cle']
);
$chemin_traites[self::harmoniserPourDoublon($chemin).'-'.$mot['id_utilisateur']] = 1;
} else {
$pbs['doublons'][self::harmoniserPourDoublon($chemin).'-'.$mot['id_utilisateur']] = $mot;
}
} else {
$pbs['vides'][] = $mot;
}
}
 
//echo '<pre>'.print_r($mots_cles_hierarchiques,true).'</pre>';exit;
return $mots_cles_hierarchiques;
}
 
static public function harmoniserPourDoublon($texte) {
$texte = htmlentities($texte, ENT_NOQUOTES, 'utf-8');
$texte = preg_replace('/&([A-za-z])(?:acute|cedil|circ|grave|orn|ring|slash|th|tilde|uml);/', '\1', $texte);
$texte = preg_replace('/&([A-za-z]{2})(?:lig);/', '\1', $texte); // pour les ligatures e.g. '&oelig;'
$texte = preg_replace('/&[^;]+;/', '', $texte); // supprime les autres caractères
 
return strtolower($texte);
}
 
static public function simplifier($text) {
// le slash est le seul caractère interdit dans les mots clés
return trim(str_replace(array('\\','/'), '', $text));
}
}
/trunk/scripts/modules/migration_mots_cles/bibliotheque/Dao.php
New file
0,0 → 1,122
<?php
// declare(encoding='UTF-8');
/**
* Contient les requêtes effecturant la migration des mots-clés.
*
* @category CEL
* @package Scripts
* @subpackage Migration : Sauvages
* @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 Dao extends Bdd {
 
private $mode;
private $table_liaison;
private $table_mots_cles;
 
public function __construct($mode) {
parent::__construct();
$this->mode = $mode;
 
if ($mode == 'obs') {
$this->table_liaison = 'cel_mots_cles_obs_liaison';
$this->table_mots_cles = 'cel_arbre_mots_cles_obs';
} else {
$this->table_liaison = 'cel_mots_cles_images_liaison';
$this->table_mots_cles = 'cel_arbre_mots_cles_images';
}
}
 
public function viderTables() {
$requete = "TRUNCATE ".$this->table_mots_cles." ";
$vidage = $this->requeter($requete.' -- '.__FILE__.':'.__LINE__);
 
$requete = "TRUNCATE ".$this->table_liaison." ";
$vidage = $this->requeter($requete.' -- '.__FILE__.':'.__LINE__);
 
return $vidage;
}
 
public function obtenirMotsClesOriginaux() {
if($this->mode == 'obs') {
$requete = "SELECT id_mot_cle_obs as id_mot_cle, ce_mot_cle_obs_parent as parent, id_utilisateur, mot_cle ".
"FROM cel_mots_cles_obs WHERE niveau != 0 AND id_utilisateur != '' ORDER BY id_utilisateur, niveau";
} else {
$requete = "SELECT id_mot_cle_image as id_mot_cle, ce_mot_cle_image_parent as parent, id_utilisateur, mot_cle ".
"FROM cel_mots_cles_images WHERE niveau != 0 AND id_utilisateur != '' ORDER BY id_utilisateur, niveau";
}
 
$mots_cles = $this->recupererTous($requete);
return $mots_cles;
}
 
public function obtenirLiaisonsMotsClesOriginaux() {
if ($this->mode == 'obs') {
$requete = "SELECT comc.id_observation AS id_element_lie, comc.id_mot_cle_obs AS id_mot_cle, id_utilisateur AS id_utilisateur ".
"FROM cel_obs_mots_cles comc ".
"INNER JOIN cel_obs o ON o.id_observation = comc.id_observation ";
} else {
$requete = "SELECT comc.id_image AS id_element_lie, comc.id_mot_cle_image AS id_mot_cle, o.ce_utilisateur AS id_utilisateur ".
"FROM cel_images_mots_cles comc ".
"INNER JOIN cel_images o ON o.id_image = comc.id_image ";
}
$liaisons = $this->recupererTous($requete);
return $liaisons;
}
 
public function insererMotsCles($mots_cles) {
$requete = "INSERT INTO ".$this->table_mots_cles." (chemin, id_utilisateur, mot_cle) VALUES ";
 
foreach ($mots_cles as $mot_cle) {
$requete .= '('.
$this->proteger($mot_cle['chemin']).', '.
$this->proteger($mot_cle['id_utilisateur']).', '.
$this->proteger($mot_cle['mot_cle']).' '.
'), ';
}
 
$requete = rtrim($requete, ', ');
return $this->requeter($requete);
}
 
public function obtenirInfosNouveauxMotsCles() {
$requete = "SELECT id_mot_cle, id_utilisateur, chemin FROM ".$this->table_mots_cles;
return $this->recupererTous($requete);
}
 
public function insererLiaisonsMotsCles($mots_cles, $liaisons, $correspondances) {
$requete = "INSERT INTO ".$this->table_liaison." (id_element_lie, id_mot_cle) VALUES ";
$lier = false;
$mot_cles_inexistants = 0;
 
foreach ($liaisons as &$liaison_mot_cle) {
$cle = $liaison_mot_cle['id_mot_cle'].'-'.$liaison_mot_cle['id_utilisateur'];
if (isset($mots_cles[$cle])) {
$cle_id_mot_cle_migre = $mots_cles[$cle]['chemin'].'-'.$liaison_mot_cle['id_utilisateur'];
if(isset($correspondances[$cle_id_mot_cle_migre])) {
$id_mot_cle_migre = $correspondances[$cle_id_mot_cle_migre]['id_mot_cle'];
$requete .= "(".
$this->proteger($liaison_mot_cle['id_element_lie']).", ".
$this->proteger($id_mot_cle_migre)." ".
"), ";
$lier = true;
} else {
$mot_cles_inexistants++;
}
}
}
 
if ($lier) {
$requete = rtrim($requete, ', ');
$this->requeter($requete);
}
if ($mot_cles_inexistants != 0) {
echo $mot_cles_inexistants."\n";
}
}
}
/trunk/scripts/modules/maintenance/Maintenance.php
New file
0,0 → 1,717
<?php
// declare(encoding='UTF-8');
/**
* Classe de maintenance de la base de données du CEL.
*
* Utilisation :
* - <code>/opt/lamp/bin/php cli.php maintenance -a (voir méthode executer)</code>
*
* @category CEL
* @package Scripts
* @subpackage Maintenance
* @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 Maintenance extends Script {
 
protected $bdd;
protected $parametres_autorises = array(
'-mc' => array(false, '1', 'Mot clef à chercher pour régénérer les machins'),
'-doublon' => array(false, '1', "Id du mot clé qu'on veut réduire à un autre"),
'-util' => array(false, null, "Id de l'utilisateur"),
'-cible' => array(false, '1', "Id de l'autre mot clé")
);
 
public function __construct($script_nom, $parametres_cli) {
parent::__construct($script_nom, $parametres_cli);
$this->bdd = new Bdd();
}
 
public function executer() {
$cmd = $this->getParametre('a');
try {
switch ($cmd) {
case 'regenererMotsClesTexteObs' :
$this->regenererMotsClesTexteObs();
break;
case 'regenererMotsClesTexteImages' :
$this->regenererMotsClesTexteImages();
break;
case 'regenererMotsClesTexteObsTout' :
$this->regenererMotsClesTexteObs(true);
break;
case 'regenererMotsClesTexteImagesTout' :
$this->regenererMotsClesTexteImages(true);
break;
case 'viderMotsClesTexteImagesSansMotsCles' :
$this->viderMotsClesTexteImagesSansMotsCles();
break;
case 'viderMotsClesTexteObsSansMotsCles' :
$this->viderMotsClesTexteObsSansMotsCles();
break;
case 'regenererChampsTailleImage' :
$this->regenererChampsTailleImage();
break;
case 'reparerLiaisonsOublieesObs' :
$this->reparerLiaisonsOublieesObs();
break;
case 'reparerLiaisonsOublieesImages' :
$this->reparerLiaisonsOublieesImages();
break;
case 'reparerLiaisonsObsParMotsClesTexte' :
$mot_clef = $this->getParametre('mc');
$this->reparerLiaisonsObsParMotsClesTexte($mot_clef);
break;
case 'reductionMotsClesImages' :
// ex: cli.php maintenance -a reductionMotsClesImages -doublon 1234 -cible 5678
$idDoublon = $this->getParametre('doublon');
$idCible = $this->getParametre('cible');
$this->reductionMotsClesImages($idDoublon, $idCible);
break;
case 'reductionMotsClesImagesUtil' :
// ex: cli.php maintenance -a reductionMotsClesImagesUtil -util 6865
$idUtilisateur = $this->obtenirParametreIntObligatoirePourMethode('util');
$this->reductionMotsClesImagesUtilisateur($idUtilisateur);
break;
case 'reduireEtNormaliserMotsClesImagesUtil' :
// ex: cli.php maintenance -a reduireEtNormaliserMotsClesImages -util 6865
$idUtilisateur = $this->obtenirParametreIntObligatoirePourMethode('util');
$this->reduireEtNormaliserMotsClesImages($idUtilisateur);
break;
case 'reduireEtNormaliserMotsClesImages' :
// ex: cli.php maintenance -a reduireEtNormaliserMotsClesImages
$this->reduireEtNormaliserMotsClesImages();
break;
case 'reductionMotsClesObs' :
// ex: cli.php maintenance -a reductionMotsClesObs -doublon 1234 -cible 5678
$idDoublon = $this->getParametre('doublon');
$idCible = $this->getParametre('cible');
$this->reductionMotsClesObs($idDoublon, $idCible);
break;
case 'reductionMotsClesObsUtil' :
// ex: cli.php maintenance -a reductionMotsClesObsUtil -util 6865
$idUtilisateur = $this->obtenirParametreIntObligatoirePourMethode('util');
$this->reductionMotsClesObsUtilisateur($idUtilisateur);
break;
case 'reduireEtNormaliserMotsClesObsUtil' :
// ex: cli.php maintenance -a reduireEtNormaliserMotsClesObs -util 6865
$idUtilisateur = $this->obtenirParametreIntObligatoirePourMethode('util');
$this->reduireEtNormaliserMotsClesObs($idUtilisateur);
break;
case 'reduireEtNormaliserMotsClesObs' :
// ex: cli.php maintenance -a reduireEtNormaliserMotsClesObs
$this->reduireEtNormaliserMotsClesObs();
break;
default :
$msg = "Erreur : la commande '$cmd' n'existe pas!\n".
"Commandes existantes : regenererMotsClesTexteObs, regenererMotsClesTexteImages"
. ", regenererMotsClesTexteObsTout, regenererMotsClesTexteImagesTout"
. ", viderMotsClesTexteImagesSansMotsCles, viderMotsClesTexteObsSansMotsCles"
. ", regenererChampsTailleImage, reparerLiaisonsOublieesObs, reparerLiaisonsOublieesImages"
. ", reparerLiaisonsObsParMotsClesTexte, reductionMotsClesImages, reductionMotsClesImagesUtil"
. ", reduireEtNormaliserMotsClesImagesUtil, reduireEtNormaliserMotsClesImages"
. ", reductionMotsClesObs, reductionMotsClesObsUtil, reduireEtNormaliserMotsClesObsUtil"
. ", reduireEtNormaliserMotsClesObs";
throw new Exception($msg);
}
} catch (Exception $e) {
$this->traiterErreur($e->getMessage());
}
}
 
private function obtenirParametreIntObligatoirePourMethode($param) {
$param_val = $this->getParametre($param);
if(!$param_val || !is_numeric($param_val)) {
$msg = "Erreur : le paramètre $param est obligatoire pour cette méthode et doit être un entier \n";
throw new Exception($msg);
}
return $param_val;
}
 
// Régénère le champ "mots_cles_texte" pour toutes les images ayant des mots clés mais ayant ce champ
// vide, suite à une erreur
protected function regenererMotsClesTexteImages($tout = false) {
$requete = 'SELECT id_image '.
'FROM cel_images '.
'WHERE id_image IN (SELECT id_element_lie FROM cel_mots_cles_images_liaison) ';
if (!$tout) {
$requete .= "AND (mots_cles_texte IS NULL OR mots_cles_texte = '') ";
}
$resultats = $this->bdd->recupererTous($requete);
echo count($resultats)." images trouvées\n";
foreach ($resultats as $image) {
$requete = 'UPDATE cel_images '.
'SET mots_cles_texte = ('.
' SELECT GROUP_CONCAT(mot_cle) '.
' FROM cel_arbre_mots_cles_images AS cm '.
' INNER JOIN cel_mots_cles_images_liaison AS cml '.
" ON (cml.id_mot_cle = cm.id_mot_cle AND cml.id_element_lie = '" . $image['id_image'] . "') ".
') '.
"WHERE id_image = '" . $image['id_image'] . "'";
$this->bdd->requeter($requete);
}
}
 
// Régénère le champ "mots_cles_texte" pour toutes les observations ayant des mots clés mais ayant ce champ
// vide, suite à une erreur
protected function regenererMotsClesTexteObs($tout = false) {
$requete = 'SELECT id_observation '.
'FROM cel_obs '.
'WHERE id_observation IN (SELECT id_element_lie FROM cel_mots_cles_obs_liaison) ';
if (!$tout) {
$requete .= "AND (mots_cles_texte IS NULL OR mots_cles_texte = '')";
}
$resultats = $this->bdd->recupererTous($requete);
echo count($resultats) . " observations trouvées\n";
foreach ($resultats as $image) {
$req = "UPDATE cel_obs SET mots_cles_texte = (SELECT GROUP_CONCAT(mot_cle) FROM cel_arbre_mots_cles_obs cm ".
"INNER JOIN cel_mots_cles_obs_liaison cml ON cml.id_mot_cle = cm.id_mot_cle AND cml.id_element_lie = '" . $image['id_observation'] . "') ".
"WHERE id_observation = '" . $image['id_observation'] . "'";
$this->bdd->requeter($req);
}
}
 
// Vide le champ "mots_cles_texte" pour toutes les images n'ayant aucun mot clé
protected function viderMotsClesTexteImagesSansMotsCles() {
$req = "UPDATE cel_images SET mots_cles_texte = NULL WHERE id_image NOT IN (SELECT id_element_lie FROM cel_mots_cles_images_liaison)";
$res = $this->bdd->requeter($req);
echo "$res images mises à jour\n";
}
 
// Vide le champ "mots_cles_texte" pour toutes les obs n'ayant aucun mot clé
protected function viderMotsClesTexteObsSansMotsCles() {
$req = "UPDATE cel_obs SET mots_cles_texte = NULL WHERE id_observation NOT IN (SELECT id_element_lie FROM cel_mots_cles_obs_liaison)";
$res = $this->bdd->requeter($req);
echo "$res observations mises à jour\n";
}
 
protected function regenererChampsTailleImage() {
$req = "SELECT id_image FROM cel_images WHERE hauteur = 0 OR largeur = 0";
$res = $this->bdd->recupererTous($req);
 
echo count($res)." images concernees \n";
echo "Début du traitement \n";
$images_maj = 0;
$image_meta_ratees = 0;
$images_inexistantes = 0;
 
foreach($res as $image) {
$chemin = $this->getCheminImage($image['id_image']);
if(file_exists($chemin)) {
list($largeur, $hauteur) = @getimagesize($chemin);
if(is_numeric($largeur) && is_numeric($hauteur)) {
$req_maj = "UPDATE cel_images SET hauteur = '".$hauteur."', largeur = '".$largeur."' ".
"WHERE id_image = '".$image['id_image']."'";
$maj_taille_image = $this->bdd->requeter($req_maj);
if($maj_taille_image) {
$images_maj++;
}
} else {
$image_meta_ratees++;
}
} else {
$images_inexistantes++;
}
$this->afficherAvancement("\tImages traitées : ", 1);
}
echo "\n";
echo "Fin de la régénération des tailles des images à partir des metadonnées \n";
echo $images_maj." images ont vu leur infos de taille régénérées \n";
echo $image_meta_ratees." images ont raté l'extraction de metadonnées \n";
echo $images_inexistantes." images n'existent pas en tant que fichier \n";
}
 
private function getCheminImage($id) {
$chemin_base = Config::get('dossierImages');
 
$id = sprintf('%09s', $id);
$id = wordwrap($id, 3 , '_', true);
 
list($dossierNiveau1, $dossierNiveau2) = explode('_', $id);
 
$chemin = $chemin_base.'/'.$dossierNiveau1.'/'.$dossierNiveau2.'/O/'.$id.'_O.jpg';
 
return $chemin;
}
 
protected function reparerLiaisonsOublieesObs() {
// Toutes les liaisons obs-motscles avec l'id utilisateur issu de la table cel obs car
// dans la table de liaison il est souvent vide
$requete_liaisons = "SELECT com.id_observation, com.id_mot_cle_obs, co.ce_utilisateur ".
"FROM `cel_obs_mots_cles` com INNER JOIN cel_obs co ON co.id_observation = com.id_observation ";
 
$liaisons = $this->bdd->recupererTous($requete_liaisons);
$nb_liaisons_originales = count($liaisons);
 
// Tous les anciens mots clés, à classer par utilisateur, puis par id mot clé
$requete_mots_cles = "SELECT id_mot_cle_obs, id_utilisateur, mot_cle FROM cel_mots_cles_obs ";
$anciens_mots_cles = $this->bdd->recupererTous($requete_mots_cles);
 
$anciens_mots_cles_fmt = array();
foreach($anciens_mots_cles as &$ancien_mot_cle) {
$id_utilisateur_ancien = $ancien_mot_cle['id_utilisateur'];
if(!isset($anciens_mots_cles_fmt[$id_utilisateur_ancien])) {
$anciens_mots_cles_fmt[$id_utilisateur_ancien] = array();
}
$anciens_mots_cles_fmt[$id_utilisateur_ancien][$ancien_mot_cle['id_mot_cle_obs']] = $ancien_mot_cle;
}
 
// Tous les nouveau mots clés, à classer par utilisateur, puis par valeur textuelle du mot
$requete_nouveaux_mots_cles = "SELECT * FROM cel_arbre_mots_cles_obs";
$nouveau_mots_cles = $this->bdd->recupererTous($requete_nouveaux_mots_cles);
 
$nouveau_mots_cles_fmt = array();
foreach($nouveau_mots_cles as &$nouveau_mot_cle) {
$id_utilisateur_nouveau = $nouveau_mot_cle['id_utilisateur'];
if(!isset($nouveau_mots_cles_fmt[$id_utilisateur_nouveau])) {
$nouveau_mots_cles_fmt[$id_utilisateur_nouveau] = array();
}
$nouveau_mots_cles_fmt[$id_utilisateur_nouveau][strtolower($nouveau_mot_cle['mot_cle'])] = $nouveau_mot_cle;
}
 
$anciens_mot_cles_pas_trouves = 0;
$nouveaux_mot_cles_pas_trouves = 0;
$utilisateurs_pas_trouves = 0;
$valeurs_a_inserer = array();
 
$ids_obs = array();
 
foreach($liaisons as &$liaison) {
$id_utilisateur_liaison = $liaison['ce_utilisateur'];
$id_mot_cle_ancien_liaison = $liaison['id_mot_cle_obs'];
 
if(isset($anciens_mots_cles_fmt[$id_utilisateur_liaison])) {
if(isset($anciens_mots_cles_fmt[$id_utilisateur_liaison][$id_mot_cle_ancien_liaison])) {
$texte_ancien_mot_cle = $anciens_mots_cles_fmt[$id_utilisateur_liaison][$id_mot_cle_ancien_liaison]['mot_cle'];
$texte_ancien_mot_cle = strtolower($texte_ancien_mot_cle); // l'astuce de ouf !
if(isset($nouveau_mots_cles_fmt[$id_utilisateur_liaison])) {
if(isset($nouveau_mots_cles_fmt[$id_utilisateur_liaison][$texte_ancien_mot_cle])) {
$nouvel_id_mot_cle = $nouveau_mots_cles_fmt[$id_utilisateur_liaison][$texte_ancien_mot_cle]['id_mot_cle'];
 
$valeurs_a_inserer[] = array(
'id_element_lie' => $liaison['id_observation'],
'id_mot_cle' => $nouvel_id_mot_cle,
'ancienne_liaison' => $liaison
);
$ids_obs[] = $liaison['id_observation'];
} else {
$nouveaux_mot_cles_pas_trouves++;
}
} else {
 
}
 
} else {
$anciens_mot_cles_pas_trouves++;
}
} else {
$utilisateurs_pas_trouves++;
}
}
 
echo "Anciennes liaisons ".$nb_liaisons_originales." \n";
echo "Liaisons à insérer ".count($valeurs_a_inserer)."\n";
echo "Utilisateurs inconnus ".$utilisateurs_pas_trouves."\n";
echo "Anciens mots clés inconnus ".$anciens_mot_cles_pas_trouves."\n";
echo "Nouveaux mots clés inconnus ".$nouveaux_mot_cles_pas_trouves."\n";
 
$tranches = array_chunk($valeurs_a_inserer, 800);
 
foreach($tranches as $tranche) {
$requete = "INSERT IGNORE INTO cel_mots_cles_obs_liaison (id_element_lie, id_mot_cle) VALUES ";
foreach($tranche as $l) {
$requete .= "('".$l['id_element_lie']."', '".$l['id_mot_cle']."'), ";
}
$requete = rtrim($requete, ',');
$insertion = $this->bdd->requeter($requete);
$this->afficherAvancement("Liaisons insérées (par paquet de 800) ", 1);
}
echo "\n";
}
 
private function reparerLiaisonsOublieesImages() {
// Toutes les liaisons obs-motscles avec l'id utilisateur issu de la table cel obs car
// dans la table de liaison il est souvent vide
$requete_liaisons = "SELECT cim.id_image, cim.id_mot_cle_image, ci.ce_utilisateur ".
"FROM cel_images_mots_cles cim INNER JOIN cel_images ci ON ci.id_image = cim.id_image ";
 
$liaisons = $this->bdd->recupererTous($requete_liaisons);
 
// Tous les anciens mots clés, à classer par utilisateur, puis par id mot clé
$requete_mots_cles = "SELECT id_mot_cle_image, id_utilisateur, mot_cle FROM cel_mots_cles_images ";
$anciens_mots_cles = $this->bdd->recupererTous($requete_mots_cles);
 
$anciens_mots_cles_fmt = array();
foreach($anciens_mots_cles as &$ancien_mot_cle) {
$id_utilisateur_ancien = $ancien_mot_cle['id_utilisateur'];
if(!isset($anciens_mots_cles_fmt[$id_utilisateur_ancien])) {
$anciens_mots_cles_fmt[$id_utilisateur_ancien] = array();
}
$anciens_mots_cles_fmt[$id_utilisateur_ancien][$ancien_mot_cle['id_mot_cle_image']] = $ancien_mot_cle;
}
 
// Tous les nouveau mots clés, à classer par utilisateur, puis par valeur textuelle du mot
$requete_nouveaux_mots_cles = "SELECT * FROM cel_arbre_mots_cles_images";
$nouveau_mots_cles = $this->bdd->recupererTous($requete_nouveaux_mots_cles);
 
$nouveau_mots_cles_fmt = array();
foreach($nouveau_mots_cles as &$nouveau_mot_cle) {
$id_utilisateur_nouveau = $nouveau_mot_cle['id_utilisateur'];
if(!isset($nouveau_mots_cles_fmt[$id_utilisateur_nouveau])) {
$nouveau_mots_cles_fmt[$id_utilisateur_nouveau] = array();
}
$nouveau_mots_cles_fmt[$id_utilisateur_nouveau][$nouveau_mot_cle['mot_cle']] = $nouveau_mot_cle;
}
 
$anciens_mot_cles_pas_trouves = 0;
$nouveaux_mot_cles_pas_trouves = 0;
$utilisateurs_pas_trouves = 0;
$valeurs_a_inserer = array();
 
foreach($liaisons as &$liaison) {
$id_utilisateur_liaison = $liaison['ce_utilisateur'];
$id_mot_cle_ancien_liaison = $liaison['id_mot_cle_image'];
 
if(isset($anciens_mots_cles_fmt[$id_utilisateur_liaison])) {
if(isset($anciens_mots_cles_fmt[$id_utilisateur_liaison][$id_mot_cle_ancien_liaison])) {
$texte_ancien_mot_cle = $anciens_mots_cles_fmt[$id_utilisateur_liaison][$id_mot_cle_ancien_liaison]['mot_cle'];
if(isset($nouveau_mots_cles_fmt[$id_utilisateur_liaison])) {
if(isset($nouveau_mots_cles_fmt[$id_utilisateur_liaison][$texte_ancien_mot_cle])) {
$nouvel_id_mot_cle = $nouveau_mots_cles_fmt[$id_utilisateur_liaison][$texte_ancien_mot_cle]['id_mot_cle'];
 
$valeurs_a_inserer[] = array(
'id_element_lie' => $liaison['id_image'],
'id_mot_cle' => $nouvel_id_mot_cle,
'ancienne_liaison' => $liaison
);
$ids_imgs[] = $liaison['id_image'];
} else {
$nouveaux_mot_cles_pas_trouves++;
}
} else {
 
}
 
} else {
$anciens_mot_cles_pas_trouves++;
}
} else {
$utilisateurs_pas_trouves++;
}
}
 
echo "Liaisons à insérer ".count($valeurs_a_inserer)."\n";
echo "Utilisateurs inconnus ".$utilisateurs_pas_trouves."\n";
echo "Anciens mots clés inconnus ".$anciens_mot_cles_pas_trouves."\n";
echo "Nouveaux mots clés inconnus ".$nouveaux_mot_cles_pas_trouves."\n";
 
$tranches = array_chunk($valeurs_a_inserer, 800);
 
foreach($tranches as $tranche) {
$requete = "INSERT IGNORE INTO cel_mots_cles_images_liaison (id_element_lie, id_mot_cle) ".
"VALUES ";
foreach($tranche as $l) {
$requete .= "('".$l['id_element_lie']."', '".$l['id_mot_cle']."'),";
}
$requete = rtrim($requete, ',');
$insertion = $this->bdd->requeter($requete);
$this->afficherAvancement("Liaisons insérées (par paquet de 800) ", 1);
}
echo "\n";
}
 
private function reparerLiaisonsObsParMotsClesTexte($mot_cle_texte_recherche) {
$ancienne_table_obs = Config::get('table_obs_recup');
$requete = "SELECT ce_utilisateur, id_observation, mots_cles_texte ".
"FROM $ancienne_table_obs ".
"WHERE mots_cles_texte LIKE '%$mot_cle_texte_recherche%' ";
$obs_a_mot_cle = $this->bdd->recupererTous($requete);
 
$requete = 'SELECT * '.
'FROM cel_arbre_mots_cles_obs '.
'WHERE id_utilisateur IN ( '.
' SELECT id_utilisateur '.
"FROM $ancienne_table_obs ".
" WHERE mots_cles_texte LIKE '%$mot_cle_texte_recherche%') ";
$nouveaux_mots_cles = $this->bdd->recupererTous($requete);
 
$mots_cles_indexes = array();
foreach($nouveaux_mots_cles as $mot_cle) {
$mots_cles_indexes[$mot_cle['id_utilisateur']][strtolower($mot_cle['mot_cle'])] = $mot_cle;
}
 
$liaisons_a_inserer = array();
$utilFoirax = 0;
$mcFoirax = 0;
foreach($obs_a_mot_cle as $obs) {
$mots_cles_texte_tab = explode(',', $obs['mots_cles_texte']);
$id_observation = $obs['id_observation'];
$id_utilisateur = $obs['ce_utilisateur'];
foreach($mots_cles_texte_tab as $mot_cle_t) {
if($mot_cle_t == $mot_cle_texte_recherche) {
if (isset($mots_cles_indexes[$id_utilisateur])) {
if (isset($mots_cles_indexes[$id_utilisateur][strtolower($mot_cle_t)])) {
$id_nouveau_mot_cle = $mots_cles_indexes[$id_utilisateur][strtolower($mot_cle_t)]['id_mot_cle'];
} else {
$mcFoirax++;
}
} else {
$utilFoirax++;
}
$liaisons_a_inserer[] = array('id_element_lie' => $id_observation, 'id_mot_cle' => $id_nouveau_mot_cle);
}
}
}
echo "Utilisateurs pas dans le tableau: $utilFoirax\n";
echo "Motf-clefs pas dans le tableau: $mcFoirax\n";
//echo '<pre>'.print_r($liaisons_a_inserer, true).'</pre>';
echo "Liaisons à insérer: " . count($liaisons_a_inserer) . " \n";
 
$requete_insertion = "INSERT IGNORE INTO cel_mots_cles_obs_liaison (id_element_lie, id_mot_cle) ".
"VALUES ";
foreach($liaisons_a_inserer as $l) {
$requete_insertion .= "('".$l['id_element_lie']."', '".$l['id_mot_cle']."'),";
}
$requete_insertion = rtrim($requete_insertion, ',');
$insertion = $this->bdd->requeter($requete_insertion);
}
 
// Change toutes les associations images - mots_cles dont l'id mot_cle est $idDoublon, pour le remplacer par $idCible
private function reductionMotsClesImages($idDoublon, $idCible, $supprimerVieuxMotsCles=true) {
echo "Réduction de $idDoublon (images) à $idCible" . PHP_EOL;
 
$q1 = "SELECT id_element_lie FROM cel_mots_cles_images_liaison WHERE id_mot_cle = $idCible;";
$r1 = $this->bdd->requeter($q1);
$idsImages = array();
foreach ($r1 as $r) {
$idsImages[] = $r['id_element_lie'];
}
 
if (count($idsImages) > 0) {
// On vire ceux qui ont le doublon mais qui ont aussi la cible
$q2 = "DELETE FROM cel_mots_cles_images_liaison WHERE id_mot_cle = $idDoublon AND id_element_lie IN (" . implode(',', $idsImages) . ");";
$r2 = $this->bdd->requeter($q2);
}
 
// On convertit tous les doublons en cible
$q3 = "UPDATE cel_mots_cles_images_liaison SET id_mot_cle = $idCible WHERE id_mot_cle = $idDoublon;";
$r3 = $this->bdd->requeter($q3);
 
if ($supprimerVieuxMotsCles) {
// On supprime le mot cle qui sert plus à rien
$q4 = "DELETE FROM cel_arbre_mots_cles_images WHERE id_mot_cle = $idDoublon;";
$r4 = $this->bdd->requeter($q4);
}
}
 
// @TODO factoriser avec reductionMotsClesImages
// Change toutes les associations obs - mots_cles dont l'id mot_cle est $idDoublon, pour le remplacer par $idCible
private function reductionMotsClesObs($idDoublon, $idCible, $supprimerVieuxMotsCles=true) {
echo "Réduction de $idDoublon (obs) à $idCible" . PHP_EOL;
 
$q1 = "SELECT id_element_lie FROM cel_mots_cles_obs_liaison WHERE id_mot_cle = $idCible;";
$r1 = $this->bdd->requeter($q1);
$idsObs = array();
foreach ($r1 as $r) {
$idsObs[] = $r['id_element_lie'];
}
 
if (count($idsObs) > 0) {
// On vire ceux qui ont le doublon mais qui ont aussi la cible
$q2 = "DELETE FROM cel_mots_cles_obs_liaison WHERE id_mot_cle = $idDoublon AND id_element_lie IN (" . implode(',', $idsObs) . ");";
$r2 = $this->bdd->requeter($q2);
}
 
// On convertit tous les doublons en cible
$q3 = "UPDATE cel_mots_cles_obs_liaison SET id_mot_cle = $idCible WHERE id_mot_cle = $idDoublon;";
$r3 = $this->bdd->requeter($q3);
 
if ($supprimerVieuxMotsCles) {
// On supprime le mot cle qui sert plus à rien
$q4 = "DELETE FROM cel_arbre_mots_cles_obs WHERE id_mot_cle = $idDoublon;";
$r4 = $this->bdd->requeter($q4);
}
}
 
private function reductionMotsClesImagesUtilisateur($idUtilisateur) {
$this->reductionMotsClesUtilisateur($idUtilisateur, "images");
}
 
private function reductionMotsClesObsUtilisateur($idUtilisateur) {
$this->reductionMotsClesUtilisateur($idUtilisateur, "obs");
}
 
// Parcourt l'arbre des mots-cles (obs ou images) de l'utilisateur dont l'id est $idUtilisateur,
// et réduit tous ceux dont le chemin n'est pas unique
private function reductionMotsClesUtilisateur($idUtilisateur, $mode = "images") {
$table = "cel_arbre_mots_cles_";
if ($mode == "images" || $mode == "obs") {
$table .= $mode;
}
$q1 = 'SELECT id_mot_cle, chemin, mot_cle, (LOCATE(mot_cle, chemin) != 0) AS valide '.
"FROM `$table` ".
"WHERE id_utilisateur = '$idUtilisateur' ".
"ORDER BY chemin ASC, valide DESC ";
$r1 = $this->bdd->requeter($q1);
 
$idsMotsCles = array();
$nbVieux = 0;
foreach ($r1 as $r) {
$k = strtolower($r['chemin']);
if (! isset($idsMotsCles[$k])) {
$idsMotsCles[$k] = array();
}
$idsMotsCles[$k][] = $r['id_mot_cle'];
$nbVieux++;
}
$nbNouveaux = count($idsMotsCles);
 
echo "Réduction de $nbVieux à $nbNouveaux mots-cles $mode" . PHP_EOL;
$aTraiter = 0;
foreach ($idsMotsCles as $chemin => $ids) {
if (count($ids) > 1) {
$aTraiter ++;
$idCible = array_shift($ids);
foreach ($ids as $idDoublon) {
if ($mode == "images") {
$this->reductionMotsClesImages($idDoublon, $idCible);
} elseif ($mode == "obs") {
$this->reductionMotsClesObs($idDoublon, $idCible);
}
}
}
}
echo "$aTraiter groupes ($mode) ont été réduits" . PHP_EOL;
}
 
private function reduireEtNormaliserMotsClesImages($util=null) {
$this->reduireEtNormaliserMotsCles('cel_arbre_mots_cles_images', 'chemin', 'images', $util);
}
 
private function reduireEtNormaliserMotsClesObs($util=null) {
$this->reduireEtNormaliserMotsCles('cel_arbre_mots_cles_obs', 'chemin', 'obs', $util);
}
 
private function reduireEtNormaliserMotsCles($table, $colonne, $mode = "images", $util=null) {
echo "Suppression des accents dans la table $table, colonne $colonne ...";
$this->supprimerAccents($table, $colonne, $util);
echo "effectuée \n";
echo "Suppression des majuscules dans la table $table, colonne $colonne ...";
$this->supprimerMajuscules($table, $colonne, $util);
echo "effectuée \n";
echo "\n";
if ($util !== null) {
echo "Réduction de tous les mots clés $mode de l'utilisateur $util\n";
if($mode == "images") {
$this->reductionMotsClesImagesUtilisateur($util);
} elseif($mode == "obs") {
$this->reductionMotsClesObsUtilisateur($util);
}
} else {
echo "Réduction de tous les mots clés $mode \n";
$req_utilisateurs = "SELECT DISTINCT id_utilisateur FROM ".$table;
$utilisateurs = $this->bdd->recupererTous($req_utilisateurs);
 
foreach($utilisateurs as $utilisateur) {
echo "Utilisateur en cours de traitement : ".$utilisateur['id_utilisateur']." \n";
if($mode == "images") {
$this->reductionMotsClesImagesUtilisateur($utilisateur['id_utilisateur']);
} elseif($mode == "obs") {
$this->reductionMotsClesObsUtilisateur($utilisateur['id_utilisateur']);
}
}
}
echo "Fin de la réduction des mots clés $mode \n";
}
 
private function supprimerMajuscules($table, $colonne, $util = null) {
$requete = "UPDATE $table SET $colonne = LOWER($colonne)";
if ($util !== null) {
$requete .= " WHERE id_utilisateur = $util";
}
$this->bdd->requeter($requete);
}
 
private function supprimerAccents($table, $colonne, $util = null) {
$requetes = array(
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Š','S')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'š','s')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ð','Dj')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ž','Z')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ž','z')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'À','A')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Á','A')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Â','A')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ã','A')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ä','A')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Å','A')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Æ','A')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ç','C')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'È','E')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'É','E')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ê','E')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ë','E')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ì','I')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Í','I')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Î','I')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ï','I')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ñ','N')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ò','O')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ó','O')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ô','O')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Õ','O')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ö','O')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ø','O')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ù','U')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ú','U')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Û','U')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ü','U')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Ý','Y')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'Þ','B')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ß','Ss')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'à','a')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'á','a')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'â','a')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ã','a')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ä','a')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'å','a')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'æ','a')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ç','c')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'è','e')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'é','e')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ê','e')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ë','e')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ì','i')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'í','i')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'î','i')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ï','i')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ð','o')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ñ','n')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ò','o')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ó','o')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ô','o')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'õ','o')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ö','o')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ø','o')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ù','u')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ú','u')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'û','u')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ý','y')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ý','y')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'þ','b')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ÿ','y')",
"UPDATE ".$table." SET ".$colonne." = REPLACE(".$colonne.",'ƒ','f')",
);
 
foreach($requetes as $requete) {
if ($util !== null) {
$requete .= " WHERE id_utilisateur = $util ";
}
$this->bdd->requeter($requete);
}
}
}