| /branches/v2.21-plantoir/scripts/modules/code_zone_geo/CodeZoneGeo.php |
|---|
| New file |
| 0,0 → 1,312 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Traitement des codes INSEE et des codes pays de la base de données CEL |
| * Permet d'affecter des codes INSEE et des codes pays aux obs possédant des coordonnées mais pas de commune ou de pays. |
| * |
| * Utilisation : |
| * - Pour ? : <code>/opt/lamp/bin/php cli.php code_zone_geo -a tout</code> |
| * - Pour ? : <code>/opt/lamp/bin/php cli.php code_zone_geo -a colonne</code> |
| * - Pour ? : <code>/opt/lamp/bin/php cli.php code_zone_geo -a payssanscorrespondance</code> |
| * - Pour ? : <code>/opt/lamp/bin/php cli.php code_zone_geo -a codeinseesanscorrespondance</code> |
| * |
| * @category CEL |
| * @package Scripts |
| * @subpackage Zones Geo |
| * @author Mathias CHOUET <mathias@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 CodeZoneGeo extends Script { |
| protected $tableauTaxon; |
| protected $dao; |
| protected $observations; |
| protected $url_service_geo_tpl; |
| protected $url_service_pays_tpl; |
| protected $mode_verbeux = false; |
| // Paramêtres autorisées lors de l'appel au script en ligne de commande |
| protected $parametres_autorises = array( |
| '-n' => array(true, true, 'Nom du fichier ou du dossier à traiter')); |
| public function executer() { |
| $this->url_service_geo_tpl = Config::get('urlZoneGeoTpl'); |
| $this->url_service_pays_tpl = Config::get('urlPaysTpl'); |
| $this->dao = new Dao(); |
| // Récupération de paramétres |
| // Lancement de l'action demandée |
| $cmd = $this->getParametre('a'); |
| $this->mode_verbeux = $this->getParametre('v'); |
| switch ($cmd) { |
| case 'tout' : |
| // à effectuer manuellement au premier lancement du script |
| $this->creerColonne(); |
| $this->calculerToutSansCorrespondanceDepuisLeDebut(); |
| break; |
| case 'colonne' : |
| $this->creerColonne(); |
| break; |
| case 'codeinseesanscorrespondance' : |
| $this->calculerCodesInseeSansCorrespondance(); |
| break; |
| case 'codeinseesanscorrespondancedepuisledebut' : |
| $this->calculerCodesInseeSansCorrespondanceDepuisLeDebut(); |
| break; |
| case 'payssanscorrespondance' : |
| $this->calculerPaysSansCorrespondance(); |
| break; |
| case 'payssanscorrespondancedepuisledebut' : |
| $this->calculerPaysSansCorrespondanceDepuisLeDebut(); |
| break; |
| case 'toutsanscorrespondance' : |
| // devrait être être l'option utilisée dans le cron quotidien (avec l'option -v 0) |
| $this->calculerToutSansCorrespondance(); |
| break; |
| case 'toutsanscorrespondancedepuisledebut' : |
| $this->calculerToutSansCorrespondanceDepuisLeDebut(); |
| break; |
| default : |
| $this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd)); |
| } |
| } |
| protected function creerColonne() { |
| $this->dao->creerColonneCodeInseeCalcule(); |
| } |
| protected function calculerCodesInseeSansCorrespondance() { |
| $liste_coordonnees = $this->dao->rechercherCoordonneesFrancaisesSansCorrespondances(); |
| $this->traiterCoordonnees($liste_coordonnees); |
| } |
| protected function calculerCodesInseeSansCorrespondanceDepuisLeDebut() { |
| $liste_coordonnees = $this->dao->rechercherCoordonneesFrancaisesSansCorrespondanceDepuisLeDebut(); |
| $this->traiterCoordonnees($liste_coordonnees); |
| } |
| protected function calculerPaysSansCorrespondance() { |
| $liste_coordonnees = $this->dao->rechercherPaysSansCorrespondance(); |
| $this->traiterCoordonnees($liste_coordonnees); |
| } |
| protected function calculerPaysSansCorrespondanceDepuisLeDebut() { |
| $liste_coordonnees = $this->dao->rechercherPaysSansCorrespondanceDepuisLeDebut(); |
| $this->traiterCoordonnees($liste_coordonnees); |
| } |
| protected function calculerToutSansCorrespondance() { |
| $this->affecterPaysFranceAuxCommunes(); |
| $liste_coordonnees = $this->dao->rechercherToutSansCorrespondance(); |
| $this->traiterCoordonnees($liste_coordonnees); |
| } |
| protected function calculerToutSansCorrespondanceDepuisLeDebut() { |
| $this->affecterPaysFranceAuxCommunes(); |
| $liste_coordonnees = $this->dao->rechercherSansCorrespondanceDepuisLeDebut(); |
| $this->traiterCoordonnees($liste_coordonnees); |
| } |
| protected function affecterPaysFranceAuxCommunes() { |
| if ($this->mode_verbeux) { |
| echo "-------------------------------------------------------------------\n"; |
| echo " Affectation du pays France aux communes ayant un code INSEE mais pas de pays ... "; |
| } |
| $maj = $this->dao->affecterPaysFranceAuxCommunesRenseignees(); |
| if ($this->mode_verbeux) { |
| echo "OK \n"; |
| echo " ".$maj." commune".($maj > 1 ? 's' : '')." affectée".($maj > 1 ? 's' : '')."\n"; |
| echo "-------------------------------------------------------------------\n"; |
| } |
| } |
| private function traiterCoordonnees($liste_coordonnees) { |
| $debut = microtime(true); |
| $nb_coordonnees_modifiees = 0; |
| $nb_coordonnees_ignorees = 0; |
| $total = count($liste_coordonnees); |
| if ($this->mode_verbeux) { |
| echo "-------------------------------------------------------------------\n"; |
| echo " Calcul des codes INSEE, du code pays et modification (".count($liste_coordonnees)." coordonnées en tout) ... \n"; |
| echo " Enrichissement des champs zone geo et ce_zone_geo vides ... \n"; |
| echo "-------------------------------------------------------------------\n"; |
| } |
| foreach ($liste_coordonnees as $coordonnees) { |
| $infos_coord = $this->obtenirInfosPourCoordonnees($coordonnees); |
| if ($infos_coord != null) { |
| // Le type renvoyé permet de connaitre ce qu'on peut modifier |
| if($infos_coord['type'] == 'france') { |
| // Cas d'une commune française |
| $coordonnee_a_traiter = array( |
| 'latitude' => $coordonnees['latitude'], |
| 'longitude' => $coordonnees['longitude'], |
| 'code_insee' => $infos_coord['code_insee'], |
| 'nom' => $infos_coord['nom'] |
| ); |
| $this->dao->modifierCodeInseeEtZoneGeo($coordonnee_a_traiter); |
| } else if($infos_coord['type'] == 'pays') { |
| // Cas d'un lieu à l'étranger |
| $coordonnee_a_traiter = array( |
| 'latitude' => $coordonnees['latitude'], |
| 'longitude' => $coordonnees['longitude'], |
| 'code_pays' => $infos_coord['code_pays'], |
| 'nom' => $infos_coord['nom'] |
| ); |
| $this->dao->modifierPays($coordonnee_a_traiter); |
| } |
| $nb_coordonnees_modifiees++; |
| } else { |
| $nb_coordonnees_ignorees++; |
| } |
| if ($this->mode_verbeux) { |
| $this->afficherAvancement(' Coordonnées traitées ', $nb_coordonnees_modifiees); |
| } |
| } |
| $fin = microtime(true); |
| if ($this->mode_verbeux) { |
| echo "\n"; |
| echo "-------------------------------------------------------------------\n"; |
| echo " Fin de la mise à jour des codes INSEE calculés, du pays et de l'enrichissement, \n"; |
| echo " ".($fin - $debut)." secondes écoulées \n"; |
| echo " ".$nb_coordonnees_modifiees." code insee calculés et modifiés \n"; |
| echo " ".$nb_coordonnees_ignorees." coordonnées ignorées \n"; |
| echo "-------------------------------------------------------------------\n"; |
| echo "\n"; |
| } |
| } |
| private function obtenirInfosPourCoordonnees($coordonnees) { |
| $infos_coord = null; |
| // Test facile qui permet d'abord de tenter une localisation bien plus rapide si les coordonnées |
| // sont dans la bounding box approximative de la France |
| if($this->testerCoordonneesWgsFrance($coordonnees['latitude'], $coordonnees['longitude'])) { |
| $infos_coord = $this->chercherInfosCommune('osm', $coordonnees['latitude'], $coordonnees['longitude']); |
| if ($infos_coord == null) { |
| // Sinon recherche par pays |
| $infos_coord = $this->chercherInfosPays($coordonnees['latitude'], $coordonnees['longitude']); |
| } |
| } else { |
| // Recherche par pays immédiate si en dehors de la bouding box française |
| $infos_coord = $this->chercherInfosPays($coordonnees['latitude'], $coordonnees['longitude']); |
| } |
| return $infos_coord; |
| } |
| private function chercherInfosCommune($projet, $latitude, $longitude) { |
| $noms_params = array('{projet}', '{latitude}', '{longitude}'); |
| $valeurs_params = array($projet, $latitude, $longitude); |
| $url_service = str_replace($noms_params, $valeurs_params, $this->url_service_geo_tpl); |
| $url_service = str_replace(',', '.', $url_service); |
| $ch = curl_init($url_service); |
| curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); |
| $reponse = curl_exec($ch); |
| $infos_coord = $this->traiterReponseServiceCommune($reponse); |
| curl_close($ch); |
| return $infos_coord; |
| } |
| private function chercherInfosPays($latitude, $longitude) { |
| $noms_params = array('{latitude}', '{longitude}'); |
| $valeurs_params = array($latitude, $longitude); |
| $url_service = str_replace($noms_params, $valeurs_params, $this->url_service_pays_tpl); |
| $url_service = str_replace(',', '.', $url_service); |
| $ch = curl_init($url_service); |
| curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); |
| $reponse = curl_exec($ch); |
| $res = json_decode($reponse, true); |
| $retour = null; |
| if(!empty($res)) { |
| // Cas où l'on a recherché des coordonnées en France |
| // On en profite pour remplir plus de données |
| // que le simple pays si elles sont présentes |
| if(isset($res[8]) && isset($res[8]['codeInsee'])) { |
| $retour = array( |
| 'code_insee' => $res[8]['codeInsee'], |
| 'nom' => $res[8]['intitule'], |
| 'type' => 'france' |
| ); |
| } else { |
| // Cas de la recherche en dehors de France |
| // La zone de plus haut niveau est toujours un pays |
| // (car le niveau de zone est limité à 2) |
| $infos_pays = $res[min(array_keys($res))]; |
| // La zone de niveau le plus bas est la "localité" |
| // la plus précise qu'on a pu trouver |
| $infos_localite = $res[max(array_keys($res))]; |
| // Cas où l'on a trouvé un code pays |
| if(!empty($infos_pays['codeIso31661'])) { |
| $retour = array( |
| 'code_pays' => $infos_pays['codeIso31661'], |
| 'nom' => '' |
| ); |
| } elseif(!empty($infos_pays['codeIso31662'])) { |
| // Quelquefois la zone de plus haut niveau est une région ou une province |
| // heureusement son code est de forme XX-YY ou XX est le code iso du pays ! |
| $retour = array( |
| 'code_pays' => substr($infos_pays['codeIso31662'], 0, 2), |
| 'nom' => '' |
| ); |
| } |
| // Pas de sens de prendre un nom de localité si on a pas de pays |
| if(!empty($retour['code_pays'])) { |
| // Type sert à savoir quelle fonction de mise à jour on appellera |
| $retour['type'] = 'pays'; |
| $retour['nom'] = $infos_localite['intitule']; |
| } |
| } |
| } |
| return $retour; |
| } |
| private function traiterReponseServiceCommune($reponse) { |
| $retour = null; |
| $reponse = json_decode($reponse); |
| // cas du service lion 1906 qui peut renvoyer plusieurs communes (on prend la première) |
| if (is_array($reponse)) { |
| $reponse = $reponse[0]; |
| } |
| if (isset($reponse->codeINSEE)) { |
| // Type sert à savoir quelle fonction de mise à jour on appellera |
| $retour = array('code_insee' => $reponse->codeINSEE, |
| 'nom' => $reponse->nom, |
| 'type' => 'france'); |
| } |
| return $retour; |
| } |
| private function testerCoordonneesWgsFrance($latitude, $longitude) { |
| $coord_france = false; |
| if ($latitude != '' && $longitude != '') { |
| if ($latitude < 51.071667 && $latitude > 41.316667) { |
| if ($longitude < 9.513333 && $longitude > -5.140278) { |
| $coord_france = true; |
| } |
| } |
| } |
| return $coord_france; |
| } |
| } |
| /branches/v2.21-plantoir/scripts/modules/code_zone_geo/code_zone_geo.sh |
|---|
| New file |
| 0,0 → 1,12 |
| #!/bin/bash |
| # |
| # /usr/local/sbin/code_zone_geo.sh : traitement du calcul des codes INSEE et pays du cel |
| # Aurélien Peronnet [11 avril 2013] |
| # |
| while true |
| do |
| logger "Lancement script cel::code_zone_geo" |
| sudo -u apitela /usr/local/bin/php-cli-56 -f /home/apitela/www/scripts/cel/cli.php code_zone_geo -a toutsanscorrespondance -v 0 |
| logger "Arret script cel::code_zone_geo" |
| sleep 86400 |
| done |
| Property changes: |
| Added: svn:eol-style |
| +native |
| \ No newline at end of property |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /branches/v2.21-plantoir/scripts/modules/code_zone_geo/bibliotheque/Dao.php |
|---|
| New file |
| 0,0 → 1,197 |
| <?php |
| class Dao extends Bdd { |
| private $temps_derniere_requete = 0; |
| public function rechercherCoordonnees($conditions = array()) { |
| if(!empty($conditions)) { |
| $where = 'WHERE '.implode(' AND ', $conditions); |
| } |
| $requete = "SELECT longitude, latitude ". |
| "FROM cel_obs ". |
| $where. |
| "GROUP BY longitude , latitude "; |
| $resultat = $this->recupererTous($requete); |
| $this->reinitialiserTempsDerniereRequete(); |
| return $resultat; |
| } |
| public function rechercherCoordonneesFrancaisesSansCorrespondances() { |
| $conditions = array( |
| $this->getConditionCoordonneesValides(), |
| $this->getConditionInfosGeoIncompletes(), |
| $this->getConditionlimiteeALaFrance(), |
| $this->getConditionModifObsRecente() |
| ); |
| return $this->rechercherCoordonnees($conditions); |
| } |
| public function rechercherCoordonneesFrancaisesSansCorrespondanceDepuisLeDebut() { |
| $conditions = array( |
| $this->getConditionCoordonneesValides(), |
| $this->getConditionInfosGeoIncompletes(), |
| $this->getConditionlimiteeALaFrance() |
| ); |
| return $this->rechercherCoordonnees($conditions); |
| } |
| public function rechercherPaysSansCorrespondance() { |
| $conditions = array( |
| $this->getConditionCoordonneesValides(), |
| $this->getConditionSansPays(), |
| $this->getConditionModifObsRecente() |
| ); |
| return $this->rechercherCoordonnees($conditions); |
| } |
| public function rechercherPaysSansCorrespondanceDepuisLeDebut() { |
| $conditions = array( |
| $this->getConditionCoordonneesValides(), |
| $this->getConditionSansPays() |
| ); |
| return $this->rechercherCoordonnees($conditions); |
| } |
| public function rechercherToutSansCorrespondance() { |
| $conditions = array( |
| $this->getConditionCoordonneesValides(), |
| '('. |
| $this->getConditionInfosGeoIncompletes().' OR '. |
| $this->getConditionSansPays(). |
| ') ', |
| $this->getConditionModifObsRecente() |
| ); |
| return $this->rechercherCoordonnees($conditions); |
| } |
| public function rechercherSansCorrespondanceDepuisLeDebut() { |
| $conditions = array( |
| $this->getConditionCoordonneesValides(), |
| '('. |
| $this->getConditionInfosGeoIncompletes().' OR '. |
| $this->getConditionSansPays(). |
| ') ' |
| ); |
| return $this->rechercherCoordonnees($conditions); |
| } |
| private function getConditionModifObsRecente() { |
| $condition = 'DATE_ADD(date_modification, INTERVAL 25 HOUR) >= CURDATE() '; |
| return $condition; |
| } |
| private function getConditionInfosGeoIncompletes() { |
| $condition = '('. |
| 'ce_zone_geo IS NULL OR ce_zone_geo = "" OR '. |
| 'zone_geo IS NULL OR zone_geo = "" '. |
| ') '; |
| return $condition; |
| } |
| private function getConditionlimiteeALaFrance() { |
| $condition = '('. |
| '(latitude <= 51.071667 AND latitude >= 41.316667) AND '. |
| '(longitude <= 9.513333 AND longitude >= -5.140278) '. |
| ') '; |
| return $condition; |
| } |
| private function getConditionSansPays() { |
| $condition = '(pays IS NULL OR pays = "XX" OR pays = "")'; |
| return $condition; |
| } |
| private function getConditionCoordonneesValides() { |
| $condition = '(latitude IS NOT NULL AND longitude IS NOT NULL '. |
| ' AND latitude != 0 AND latitude != "" '. |
| ' AND longitude != 0 AND longitude != "" '. |
| ' AND latitude >= -90 AND latitude <= 90 '. |
| ' AND longitude >= -180 AND longitude <= 180) '; |
| return $condition; |
| } |
| public function creerColonneCodeInseeCalcule() { |
| $create = 'ALTER TABLE cel_obs '. |
| 'ADD code_insee_calcule VARCHAR(5) NOT NULL '; |
| $this->requeter($create); |
| $this->reinitialiserTempsDerniereRequete(); |
| } |
| public function ajouterCodeInseeCalcule($latitude, $longitude, $code_insee) { |
| $insert = 'UPDATE cel_obs '. |
| "SET ". |
| "code_insee_calcule = ".$this->proteger($code_insee)." ". |
| "WHERE latitude = ".$this->proteger($latitude)." ". |
| " AND longitude = ".$this->proteger($longitude)." "; |
| $this->requeter($insert); |
| $this->reinitialiserTempsDerniereRequete(); |
| } |
| public function affecterPaysFranceAuxCommunesRenseignees() { |
| $update = "UPDATE cel_obs SET pays = 'FR' ". |
| "WHERE ". |
| "ce_zone_geo LIKE 'INSEE-C:_____' AND ". |
| "zone_geo != '' AND ". |
| "zone_geo IS NOT NULL AND ". |
| "(pays IS NULL OR pays = '') "; |
| return $this->executer($update); |
| } |
| public function modifierCodeInseeEtZoneGeo($coordonnees) { |
| $codeP = $this->proteger($coordonnees['code_insee']); |
| $codeInseeP = $this->proteger('INSEE-C:'.$coordonnees['code_insee']); |
| $nomP = $this->proteger($coordonnees['nom']); |
| $update = "UPDATE cel_obs ". |
| "SET ". |
| "pays = 'FR', ". |
| "code_insee_calcule = ".$codeP.", ". |
| "ce_zone_geo = ".$codeInseeP.", ". |
| "zone_geo = IF(zone_geo = '' OR zone_geo = NULL, ".$nomP.", zone_geo) ". |
| "WHERE ". |
| " latitude = ".$this->proteger($coordonnees['latitude'])." ". |
| " AND longitude = ".$this->proteger($coordonnees['longitude'])." "; |
| $this->requeter($update); |
| $this->reinitialiserTempsDerniereRequete(); |
| } |
| public function modifierPays($coordonnees) { |
| $codePaysP = $this->proteger($coordonnees['code_pays']); |
| $nomP = $this->proteger($coordonnees['nom']); |
| $update = "UPDATE cel_obs ". |
| "SET ". |
| "pays = ".$codePaysP.", ". |
| "zone_geo = IF(zone_geo = '' OR zone_geo = NULL, ".$nomP.", zone_geo) ". |
| "WHERE ". |
| " latitude = ".$this->proteger($coordonnees['latitude'])." ". |
| " AND longitude = ".$this->proteger($coordonnees['longitude'])." "; |
| $this->requeter($update); |
| $this->reinitialiserTempsDerniereRequete(); |
| } |
| // Il peut se passer assez de temps sans qu'aucune requete ne soit effectuée |
| // (cas d'un grand nombre d'enregistrements à la suite pour lesquels on ne trouve |
| // aucun département). Pour éviter cela on teste régulièrement la connection |
| public function testerActiviteConnection() { |
| $temps_courant = microtime(true); |
| $temps_depuis_derniere_requete = $temps_courant - $this->temps_derniere_requete; |
| if($temps_depuis_derniere_requete >= 18) { |
| $this->ping(); |
| $this->reinitialiserTempsDerniereRequete(); |
| } |
| } |
| private function reinitialiserTempsDerniereRequete() { |
| $this->temps_derniere_requete = microtime(true); |
| } |
| } |
| /branches/v2.21-plantoir/scripts/modules/generation_images/GenerationImages.php |
|---|
| New file |
| 0,0 → 1,76 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Génère des miniatures. |
| * |
| * Utilisation : |
| * - Pour ? : <code>/opt/lamp/bin/php cli.php generation_images -a genererMinaturesEnAttente</code> |
| * - Pour ? : <code>/opt/lamp/bin/php cli.php generation_images -a genererMinaturesEnAttente</code> |
| * |
| * @category CEL |
| * @package Scripts |
| * @subpackage Génération Images |
| * @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 GenerationImages extends Script { |
| protected $bdd; |
| protected $parametres_autorises = array( |
| '-id' => array(false, '1', 'Identifiants des images à traiter (séparés par des virgules') |
| ); |
| public function __construct($script_nom, $parametres_cli) { |
| parent::__construct($script_nom, $parametres_cli); |
| $this->bdd = new Bdd(); |
| } |
| public function executer() { |
| $cmd = $this->getParametre('a'); |
| switch($cmd) { |
| case 'genererMinaturesEnAttente'; |
| $this->genererMiniaturesEnAttente(); |
| break; |
| case 'genererMinaturesPourId'; |
| $this->genererMinaturesPourId(); |
| break; |
| default : |
| $msg = "Erreur : la commande '$cmd' n'existe pas!\n"; |
| throw new Exception($msg); |
| } |
| } |
| private function genererMinaturesPourId() { |
| $id = $this->getParametre('id'); |
| $ids = explode(',',$id); |
| if ($id == null) { |
| echo "le paramètre id doit être un ensemble de nombres séparés par des virgules"; |
| } else { |
| include_once dirname(__FILE__).'/bibliotheque/ImageRecreation.php'; |
| $createur_images = new ImageRecreation(); |
| foreach ($ids as $id_image) { |
| $createur_images->regenererMiniaturesPourId(array($id_image)); |
| } |
| } |
| } |
| private function genererMiniaturesEnAttente() { |
| $requete = 'SELECT id_image '. |
| 'FROM cel_images '. |
| 'WHERE date_creation >= DATE_SUB(NOW(), INTERVAL 15 MINUTE)'; |
| $images_attente = $this->bdd->recupererTous($requete); |
| if (!empty($images_attente)) { |
| // iterer sur config pour formats |
| include_once dirname(__FILE__).'/bibliotheque/ImageRecreation.php'; |
| $createur_images = new ImageRecreation(); |
| foreach ($images_attente as $image) { |
| $createur_images->regenererMiniaturesPourId(array($image['id_image'])); |
| } |
| } |
| } |
| } |
| /branches/v2.21-plantoir/scripts/modules/generation_images/bibliotheque/ImageRecreation.php |
|---|
| New file |
| 0,0 → 1,669 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Cette classe est un quasi copier-coller de la classe éponyme dans |
| * le dossier lib de jrest mais pas de mécanisme commun pour les classes |
| * |
| * @category CEL |
| * @package Scripts |
| * @subpackage Génération Images |
| * @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> |
| */ |
| // TODO: utiliser la même classe pour jrest ainsi que les scripts => créer un projet cel-commun (même principe que del-commun) |
| Class ImageRecreation { |
| private $droits = 0755; |
| private $formats = array('CRX2S','CRXS','CXS','CS','CRS','XS','S','M','L','XL','X2L','X3L'); |
| const MODE_GD = 'gd'; |
| const MODE_IMAGEMAGICK = 'imagemagick'; |
| private $mode; |
| private $verbose = true; |
| public function __construct() { |
| if (extension_loaded('imagick')) { |
| $this->mode = self::MODE_IMAGEMAGICK; |
| } else { |
| $this->mode = self::MODE_GD; |
| } |
| } |
| public function recreerMiniaturesRecursivement() { |
| $this->itererRecursivement(Config::get('dossierImages')); |
| } |
| public function regenererMiniaturesIntervalle($params) { |
| $id_debut = $params[0]; |
| $id_fin = $params[1]; |
| if (is_numeric($id_debut) && is_numeric($id_fin)) { |
| for ($i = $id_debut; $i <= $id_fin; $i++) {; |
| $tab_param = array($i); |
| $this->regenererMiniaturesPourId($tab_param); |
| } |
| } |
| } |
| public function regenererMiniaturesPourId($params) { |
| $id = $params[0]; |
| if (!is_numeric($id)) { |
| return; |
| } |
| $dossier_fichier = $this->obtenirDossierPourFormat($id, 'O'); |
| $nom_fichier = $this->convertirIdBddVersNomFichier($id, 'O'); |
| $chemin_fichier = $dossier_fichier.'/'.$nom_fichier; |
| if (file_exists($chemin_fichier)) { |
| $infos_image_originale = $this->obtenirImageEtInfosPourChemin($chemin_fichier); |
| // obtention d'un verrou sur le fichier original pour empecher d'autres scripts |
| // d'effectuer la création des miniatures |
| $fp = fopen($chemin_fichier, "r"); |
| $verrou = flock($fp, LOCK_EX); |
| // creation de miniatures pour chacuns des formats définis |
| foreach ($this->formats as $format) { |
| $this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format); |
| }; |
| $verrou = flock($fp, LOCK_UN); |
| fclose($fp); |
| } |
| } |
| public function itererRecursivement($dossier) { |
| // on ne parse que le dossier des images originales |
| $dossiers_a_exclure = $this->getFormats(); |
| foreach (new DirectoryIterator($dossier) as $fichier_ou_dossier) { |
| if ($fichier_ou_dossier->isDot()) { |
| continue; |
| } |
| if (in_array($fichier_ou_dossier->getBasename(), $dossiers_a_exclure)) { |
| continue; |
| } |
| if ($fichier_ou_dossier->isDir()) { |
| $this->itererRecursivement($fichier_ou_dossier->getPathname()); |
| } else { |
| $nom_fichier = $fichier_ou_dossier->getFilename(); |
| $infos_image_originale = $this->obtenirImageEtInfosPourChemin($fichier_ou_dossier->getPathname()); |
| $id = $this->convertirBaseNomFichierVersIdBdd($nom_fichier, $this->formats); |
| // creation de miniatures pour chacuns des formats définis |
| foreach ($this->formats as $format) { |
| $this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format); |
| } |
| } |
| } |
| } |
| public function creerOuRenvoyerImage($id, $format) { |
| $dossier = $this->obtenirDossierPourFormat($id, $format); |
| $nom_fichier = $this->convertirIdBddVersNomFichier($id, $format); |
| $chemin_image = $dossier.'/'.$nom_fichier; |
| $image = false; |
| if(!file_exists($chemin_image)) { |
| $infos_image_originale = $this->obtenirImageEtInfosPourChemin($this->obtenirCheminImageOriginale($id)); |
| if($infos_image_originale) { |
| $debut = microtime(); |
| $this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale, $format); |
| $image = file_get_contents($chemin_image); |
| } |
| } else { |
| $image = file_get_contents($chemin_image); |
| } |
| return $image; |
| } |
| public function creerMiniatureImageSelonFormat($infos_image_originale, $format = 'O') { |
| if ($format == 'O') { |
| // format original : rien à faire |
| $image_redimensionnee = $infos_image_originale['image']; |
| } else { |
| if ($this->estUnFormatRogne($format)) { |
| if ($this->mode == self::MODE_IMAGEMAGICK) { |
| // si l'on dispose de la librairie imageMagick |
| // on applique l'algorithme d'auto détection de sujets |
| // qui centre la miniature sur le sujet de l'image |
| $image_redimensionnee = $this->opticrop($infos_image_originale, $format); |
| } else { |
| // si l'on ne dispose que de gd |
| // la minature est une image redimensionnée rognée au centre |
| $image_redimensionnee = $this->creerMiniatureCarreeRognee($infos_image_originale, $format); |
| } |
| } else if ($this->estUnFormatCarre($format)) { |
| // le format carre et une image redimensionnée en gardant son ratio, insérée dans un carré blanc |
| $image_redimensionnee = $this->creerMiniatureCarree($infos_image_originale, $format); |
| } else { |
| $image_redimensionnee = $this->creerMiniature($infos_image_originale, $format); |
| } |
| } |
| return $image_redimensionnee; |
| } |
| public function stockerFichierOriginal($fichier, $id) { |
| $chemin_fichier_origine = is_array($fichier) ? $fichier['tmp_name'] : $fichier; |
| $chemin_base_fichier = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, 'O'); |
| $nom_fichier = $this->convertirIdBddVersNomFichier($id, 'O'); |
| $chemin_fichier = $chemin_base_fichier.'/'.$nom_fichier; |
| $deplacement_fichier = $this->stockerImageExterne($chemin_fichier_origine, $chemin_fichier); |
| if ($deplacement_fichier) { |
| $infos_image_originale = $this->obtenirImageEtInfosPourChemin($chemin_fichier); |
| $taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']); |
| if ($taux_compression < 100 && $this->mode == self::MODE_IMAGEMAGICK) { |
| $this->ecrireImageSurDisqueAvecMeta($chemin_fichier, $taux_compression); |
| } |
| return $infos_image_originale; |
| } else { |
| $erreur = 'ERROR : probleme durant le déplacement du fichier temporaire \n' ; |
| $this->logger('CEL_bugs',$erreur); |
| return false ; |
| } |
| } |
| public function stockerFichierEtCreerMiniatures($fichier, $id) { |
| $infos_image_originale_stockee = $this->stockerFichierOriginal($fichier, $id); |
| if($infos_image_originale_stockee) { |
| $formats = $this->getFormats(); |
| // creation de miniatures pour chacuns des formats définis |
| foreach($formats as $format) { |
| $this->creerEtStockerMiniatureFichierImageSelonFormat($id, $infos_image_originale_stockee, $format); |
| } |
| } else { |
| $erreur = 'ERROR : impossible d\'obtenir les informations sur l\'image originale \n' ; |
| $this->logger('CEL_bugs',$erreur); |
| return false ; |
| } |
| return true ; |
| } |
| public function creerEtStockerMiniatureFichierImageSelonFormat($id ,$infos_image_originale, $format = 'O') { |
| $image_redimensionnee = $this->creerMiniatureImageSelonFormat($infos_image_originale, $format); |
| $taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']); |
| $this->ecrireImageSurDisque($image_redimensionnee, $id, $format, $taux_compression); |
| return true; |
| } |
| public function creerImageRedimensionnee($infos_image_originale, $hauteur_redimension, $largeur_redimension) { |
| $image_redimensionnee = imagecreatetruecolor($largeur_redimension, $hauteur_redimension); |
| imagecopyresampled($image_redimensionnee, |
| $infos_image_originale['image'], |
| 0, 0, |
| 0, 0, |
| $largeur_redimension, |
| $hauteur_redimension, |
| $infos_image_originale['largeur'], |
| $infos_image_originale['hauteur'] |
| ); |
| return $image_redimensionnee; |
| } |
| public function creerMiniature($informations_images, $format) { |
| $taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format); |
| $taille_image_redimensionnee = $this->calculerTailleImage($informations_images, $taille_reference_pour_format['hauteur']); |
| $image_redimensionnee = $this->creerImageRedimensionnee($informations_images, $taille_image_redimensionnee['hauteur'], $taille_image_redimensionnee['largeur']); |
| return $image_redimensionnee; |
| } |
| public function creerMiniatureCarree($informations_image, $format) { |
| $taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format); |
| $cote_carre = $taille_reference_pour_format['largeur']; |
| $image_redimensionnee_avec_rapport = $this->creerMiniature($informations_image, $format); |
| $taille_redimensionnee_avec_rapport = $this->calculerTailleImage($informations_image, $taille_reference_pour_format['hauteur']); |
| if ($this->estPaysage($informations_image)) { |
| $debut_largeur_a_copier = 0 ; |
| $debut_hauteur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['hauteur'])/2 ; |
| } else { |
| $debut_largeur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['largeur'])/2 ; |
| $debut_hauteur_a_copier = 0 ; |
| } |
| $image_carre_blanc_cible = $this->renvoyerEtCreerImageCarreeBlancheSelonFormat($cote_carre); |
| imagecopy($image_carre_blanc_cible, $image_redimensionnee_avec_rapport, |
| $debut_largeur_a_copier ,$debut_hauteur_a_copier, 0, 0, |
| $taille_redimensionnee_avec_rapport['largeur'], $taille_redimensionnee_avec_rapport['hauteur'] |
| ); |
| return $image_carre_blanc_cible; |
| } |
| public function creerMiniatureCarreeRognee($informations_image, $format) { |
| $taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format); |
| $cote_carre = $taille_reference_pour_format['largeur']; |
| $cote_carre_non_redimensionne = 0; |
| if ($this->estPaysage($informations_image)) { |
| $cote_carre_non_redimensionne = $informations_image['hauteur']; |
| $debut_largeur_a_copier = ($informations_image['hauteur'] - $cote_carre)/2 ; |
| $debut_hauteur_a_copier = 0; |
| if($debut_largeur_a_copier <= 0) { |
| $debut_largeur_a_copier = 0; |
| } |
| $nb_pixels_largeur_a_copier = $cote_carre_non_redimensionne; |
| $nb_pixels_hauteur_a_copier = $cote_carre_non_redimensionne; |
| } else { |
| $cote_carre_non_redimensionne = $informations_image['largeur']; |
| $debut_largeur_a_copier = 0 ; |
| $debut_hauteur_a_copier = ($informations_image['largeur'] - $cote_carre)/2; |
| if ($debut_hauteur_a_copier <= 0) { |
| $debut_hauteur_a_copier = 0; |
| } |
| $nb_pixels_largeur_a_copier = $cote_carre_non_redimensionne; |
| $nb_pixels_hauteur_a_copier = $cote_carre_non_redimensionne; |
| } |
| $image_carre_temporaire = imagecreatetruecolor($cote_carre_non_redimensionne, $cote_carre_non_redimensionne); |
| imagecopyresampled($image_carre_temporaire, |
| $informations_image['image'], |
| 0, 0, |
| $debut_largeur_a_copier, |
| $debut_hauteur_a_copier, |
| $cote_carre_non_redimensionne, |
| $cote_carre_non_redimensionne, |
| $nb_pixels_largeur_a_copier, |
| $nb_pixels_hauteur_a_copier |
| ); |
| $image_redimensionnee = imagecreatetruecolor($cote_carre, $cote_carre); |
| imagecopyresampled($image_redimensionnee, |
| $image_carre_temporaire, |
| 0, 0, |
| 0, 0, |
| $cote_carre, |
| $cote_carre, |
| $cote_carre_non_redimensionne, |
| $cote_carre_non_redimensionne |
| ); |
| return $image_redimensionnee; |
| } |
| public function stockerImageExterne($chemin_fichier_temp, $chemin_destination) { |
| if (is_uploaded_file($chemin_fichier_temp)) { |
| $deplacement = move_uploaded_file($chemin_fichier_temp, $chemin_destination); |
| } else { |
| $deplacement = rename($chemin_fichier_temp, $chemin_destination); |
| } |
| return $deplacement; |
| } |
| public function creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, $format) { |
| $chemin_sur_serveur_final = $this->obtenirDossierPourFormat($id, $format); |
| if (!file_exists($chemin_sur_serveur_final)) { |
| umask(0); |
| if (!mkdir($chemin_sur_serveur_final, $this->droits, true)) { |
| $erreur = 'ERROR : probleme durant l\'écriture du dossier '.$format.' \n' ; |
| $this->logger('CEL_bugs', $erreur); |
| return false; |
| } |
| } |
| return $chemin_sur_serveur_final; |
| } |
| public function obtenirDossierPourFormat($id, $format) { |
| $chemin_base = Config::get('dossierImages'); |
| $chemin_sur_serveur = $chemin_base; |
| $id = sprintf('%09s', $id); |
| $id = wordwrap($id, 3 , '_', true); |
| list($dossierNiveau1, $dossierNiveau2) = explode('_', $id); |
| $chemin_sur_serveur_final = $chemin_sur_serveur.'/'.$dossierNiveau1.'/'.$dossierNiveau2.'/'.$format; |
| return $chemin_sur_serveur_final; |
| } |
| public function obtenirCheminImageOriginale($id_image) { |
| $nom = $this->convertirIdBddVersNomFichier($id_image, 'O'); |
| $dossier = $this->obtenirDossierPourFormat($id_image,'O'); |
| return $dossier.'/'.$nom; |
| } |
| public function obtenirImageEtInfosPourId($id_image) { |
| $chemin_image_o = $this->obtenirCheminImageOriginale($id_image); |
| return $this->obtenirImageEtInfosPourChemin($chemin_image_o); |
| } |
| public function obtenirImageEtInfosPourChemin($chemin_fichier) { |
| $image_et_infos = false; |
| if (file_exists($chemin_fichier)) { |
| $image_et_infos = array(); |
| list($image_et_infos['largeur'], $image_et_infos['hauteur']) = getimagesize($chemin_fichier); |
| $image_et_infos['poids_octets'] = filesize($chemin_fichier); |
| $image_et_infos['image'] = imagecreatefromjpeg($chemin_fichier); |
| $image_et_infos['chemin'] = $chemin_fichier; |
| } |
| return $image_et_infos; |
| } |
| public function obtenirDimensionsPourFormat($format) { |
| $dimensions = array('largeur' => 0, 'hauteur' => 0); |
| if (Config::get('format_'.$format) != null) { |
| list($dimensions['largeur'], $dimensions['hauteur']) = explode('_', Config::get('format_'.$format)); |
| } |
| return $dimensions; |
| } |
| public function calculerTailleImage($informations_images, $taille_max) { |
| $HL_redimension = array(); |
| if ($this->estPaysage($informations_images)) { |
| $rapport = $informations_images['hauteur']/$informations_images['largeur'] ; |
| $HL_redimension['largeur'] = round($taille_max) ; |
| $HL_redimension['hauteur'] = round($taille_max*$rapport) ; |
| } else { |
| $rapport = $informations_images['largeur']/$informations_images['hauteur'] ; |
| $HL_redimension['hauteur'] = round($taille_max) ; |
| $HL_redimension['largeur'] = round($taille_max*$rapport) ; |
| } |
| return $HL_redimension; |
| } |
| public function getFormats() { |
| return $this->formats; |
| } |
| public function estUnFormatCarre($format) { |
| return (strpos($format,'C') === 0); |
| } |
| public function estUnFormatRogne($format) { |
| return (strpos($format,'R') === 1); |
| } |
| public function estPaysage($informations_images) { |
| return $informations_images['largeur'] > $informations_images['hauteur']; |
| } |
| public function estPortait($informations_images) { |
| return $informations_images['largeur'] < $informations_images['hauteur']; |
| } |
| public function renvoyerTauxCompressionPourPoids($poids_octets) { |
| $poids_max_octets = Config::get('tailleMaxImages'); |
| $ratio_compression = 100 ; |
| if ($poids_octets >= $poids_max_octets) { |
| $ratio_compression = 75 ; |
| } |
| return $ratio_compression; |
| } |
| public function convertirIdBddVersNomFichier($id, $format, $extension = 'jpg') { |
| // creation du format original |
| $id_avec_zeros = sprintf('%09s', $id) ; |
| $id_avec_zeros_underscores = wordwrap($id_avec_zeros, 3 , '_', true) ; |
| $nom_fichier = $id_avec_zeros_underscores.'_'.$format.'.'.$extension; |
| return $nom_fichier; |
| } |
| public function convertirBaseNomFichierVersIdBdd($nom_fichier, $formats) { |
| $nom_fichier_sans_extension = trim($nom_fichier, '.jpg'); |
| foreach($formats as $format) { |
| $nom_fichier_sans_extension = trim($nom_fichier_sans_extension, '_'.$format); |
| } |
| $id_image = str_replace('_', '', $nom_fichier_sans_extension); |
| // suppression des 0 devant |
| $id_image += 0; |
| return $id_image; |
| } |
| public function ecrireImageSurDisque($image_binaire, $id, $format, $compression = 100) { |
| umask(0); |
| $chemin_sur_serveur_final = $this->creerSiNecessaireEtRenvoyerCheminStockageFichierPourIdEtFormat($id, $format); |
| $nom_fichier = $this->convertirIdBddVersNomFichier($id, $format); |
| if (file_exists($chemin_sur_serveur_final.'/'.$nom_fichier)) { |
| unlink($chemin_sur_serveur_final.'/'.$nom_fichier); |
| } |
| // attention, ceci ne preserve pas les metadonnées |
| imagejpeg($image_binaire, $chemin_sur_serveur_final.'/'.$nom_fichier, $compression); |
| chmod($chemin_sur_serveur_final.'/'.$nom_fichier,$this->droits); |
| } |
| public function ecrireImageSurDisqueAvecMeta($chemin_image_a_stocker, $compression = 100) { |
| $img = new Imagick($chemin_image_a_stocker); |
| // l'utilisation d'image magick préserve les métadonnées lors d'une recompression |
| $img->setformat("jpeg"); |
| $img->setImageCompression(imagick::COMPRESSION_JPEG); |
| $img->setCompressionQuality($compression); |
| $img->writeImage($chemin_image_a_stocker); |
| $img->destroy(); |
| chmod($chemin_image_a_stocker, $this->droits); |
| } |
| public function renvoyerEtCreerImageCarreeBlancheSelonFormat($cote) { |
| $image_blanche = imagecreatetruecolor($cote, $cote); |
| $blanc = imagecolorallocate($image_blanche, 255, 255, 255); |
| imagefilledrectangle($image_blanche, 0, 0, $cote, $cote, $blanc); |
| return $image_blanche; |
| } |
| public function detruireImageEnMemoire($image) { |
| imagedestroy($image); |
| } |
| public function detruireImageSurDisque($id) { |
| $formats = $this->getFormats(); |
| // on detruit aussi l'image originale |
| $formats[] = 'O'; |
| $destruction_formats_fichier = false; |
| // destructions de chacuns des formats définis |
| foreach($formats as $format) { |
| $dossier_format = $this->obtenirDossierPourFormat($id, $format); |
| $nom_fichier = $this->convertirIdBddVersNomFichier($id, $format); |
| if (file_exists($dossier_format.'/'.$nom_fichier)) { |
| $destruction_formats_fichier = unlink($dossier_format.'/'.$nom_fichier); |
| } else { |
| $destruction_formats_fichier = true; |
| } |
| } |
| return $destruction_formats_fichier; |
| } |
| /* |
| * edge-maximizing crop |
| * determines center-of-edginess, then tries different-sized crops around it. |
| * picks the crop with the highest normalized edginess. |
| * see documentation on how to tune the algorithm |
| * |
| * $informations_image - le tableau d'informations sur l'image tel que renvoyé par la fonction obtenirImageEtInfosPourChemin |
| * $format - le format (ex. : CS, XS, XL, CRS) |
| */ |
| public function opticrop($informations_image, $format) { |
| umask(0); |
| $nom_temp = md5(time()); |
| $chemin_temp = |
| $out = Config::get('dossierImagesStockageTemp').'/'.$nom_temp; |
| $dimension_vignettes = $this->obtenirDimensionsPourFormat($format); |
| $largeur_vignette = $dimension_vignettes['largeur']; |
| $hauteur_vignette = $dimension_vignettes['hauteur']; |
| // source dimensions |
| $largeur_image_originale = $informations_image['largeur']; |
| $hauteur_image_originale = $informations_image['hauteur']; |
| $chemin_image = $informations_image['chemin']; |
| //if ($largeur_vignette > $largeur_image_originale || $hauteur_vignette > $hauteur_image_originale) |
| // die("Target dimensions must be smaller or equal to source dimensions."); |
| // parameters for the edge-maximizing crop algorithm |
| $r = 1; // radius of edge filter |
| $nk = 9; // scale count: number of crop sizes to try |
| $gamma = 0.2; // edge normalization parameter -- see documentation |
| $ar = $largeur_vignette/$hauteur_vignette; // target aspect ratio (AR) |
| $ar0 = $largeur_image_originale/$hauteur_image_originale; // original aspect ratio (AR) |
| $img = new Imagick($chemin_image); |
| $imgcp = clone $img; |
| // compute center of edginess |
| $img->edgeImage($r); |
| $img->modulateImage(100,0,100); // grayscale |
| $img->blackThresholdImage("#0f0f0f"); |
| $img->writeImage($out); |
| // use gd for random pixel access |
| $im = ImageCreateFromJpeg($out); |
| $xcenter = 0; |
| $ycenter = 0; |
| $sum = 0; |
| $n = 100000; |
| for ($k=0; $k<$n; $k++) { |
| $i = mt_rand(0,$largeur_image_originale-1); |
| $j = mt_rand(0,$hauteur_image_originale-1); |
| $val = imagecolorat($im, $i, $j) & 0xFF; |
| $sum += $val; |
| $xcenter += ($i+1)*$val; |
| $ycenter += ($j+1)*$val; |
| } |
| $xcenter /= $sum; |
| $ycenter /= $sum; |
| // crop source img to target AR |
| if ($largeur_image_originale/$hauteur_image_originale > $ar) { |
| // source AR wider than target |
| // crop width to target AR |
| $wcrop0 = round($ar*$hauteur_image_originale); |
| $hcrop0 = $hauteur_image_originale; |
| } else { |
| // crop height to target AR |
| $wcrop0 = $largeur_image_originale; |
| $hcrop0 = round($largeur_image_originale/$ar); |
| } |
| // crop parameters for all scales and translations |
| $params = array(); |
| // crop at different scales |
| $hgap = $hcrop0 - $hauteur_vignette; |
| $hinc = ($nk == 1) ? 0 : $hgap / ($nk - 1); |
| $wgap = $wcrop0 - $largeur_vignette; |
| $winc = ($nk == 1) ? 0 : $wgap / ($nk - 1); |
| // find window with highest normalized edginess |
| $n = 10000; |
| $maxbetanorm = 0; |
| $maxfile = ''; |
| $maxparam = array('w'=>0, 'h'=>0, 'x'=>0, 'y'=>0); |
| for ($k = 0; $k < $nk; $k++) { |
| $hcrop = round($hcrop0 - $k*$hinc); |
| $wcrop = round($wcrop0 - $k*$winc); |
| $xcrop = $xcenter - $wcrop / 2; |
| $ycrop = $ycenter - $hcrop / 2; |
| //echo("crop: $wcrop, $hcrop, $xcrop, $ycrop"); |
| if ($xcrop < 0) $xcrop = 0; |
| if ($xcrop+$wcrop > $largeur_image_originale) $xcrop = $largeur_image_originale-$wcrop; |
| if ($ycrop < 0) $ycrop = 0; |
| if ($ycrop+$hcrop > $hauteur_image_originale) $ycrop = $hauteur_image_originale-$hcrop; |
| $beta = 0; |
| for ($c=0; $c<$n; $c++) { |
| $i = mt_rand(0,$wcrop-1); |
| $j = mt_rand(0,$hcrop-1); |
| $beta += imagecolorat($im, $xcrop+$i, $ycrop+$j) & 0xFF; |
| } |
| $area = $wcrop * $hcrop; |
| $betanorm = $beta / ($n*pow($area, $gamma-1)); |
| // echo("beta: $beta; betan: $betanorm"); |
| // echo("image$k.jpg:<br/>\n<img src=\"$currfile\"/>"); |
| // best image found, save it |
| if ($betanorm > $maxbetanorm) { |
| $maxbetanorm = $betanorm; |
| $maxparam['w'] = $wcrop; |
| $maxparam['h'] = $hcrop; |
| $maxparam['x'] = $xcrop; |
| $maxparam['y'] = $ycrop; |
| } |
| } |
| // return image |
| $imgcp->cropImage($maxparam['w'], $maxparam['h'], $maxparam['x'], $maxparam['y']); |
| $imgcp->scaleImage($largeur_vignette, $hauteur_vignette); |
| $imgcp->writeImage($out); |
| chmod($out, 0777); |
| $img->destroy(); |
| $imgcp->destroy(); |
| $image_sortie = ImageCreateFromJpeg($out); |
| unlink($out); |
| return $image_sortie; |
| } |
| } |
| /branches/v2.21-plantoir/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. 'œ' |
| $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)); |
| } |
| } |
| /branches/v2.21-plantoir/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"; |
| } |
| } |
| } |
| /branches/v2.21-plantoir/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); |
| } |
| } |
| } |
| /branches/v2.21-plantoir/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); |
| } |
| } |
| /branches/v2.21-plantoir/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; |
| } |
| } |
| /branches/v2.21-plantoir/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"); |
| } |
| } |
| } |
| } |
| /branches/v2.21-plantoir/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); |
| } |
| } |
| /branches/v2.21-plantoir/scripts/configurations/config.defaut.ini |
|---|
| New file |
| 0,0 → 1,65 |
| ; Encodage : UTF-8 |
| ; +------------------------------------------------------------------------------------------------------+ |
| ; Info sur l'application |
| info.nom = Scripts du CEL |
| ; Abréviation de l'application |
| info.abr = CEL-SCRIPTS |
| ; Version du Framework nécessaire au fonctionnement de cette application |
| info.framework.version = 0.4 |
| ; Encodage de l'application |
| encodage_appli = "UTF-8" |
| ; Chemin de l'application (pour l'utiliser dans ce fichier) |
| chemin_scripts = "php:Framework::getCheminAppli()" |
| ; +------------------------------------------------------------------------------------------------------+ |
| ; Débogage |
| ; Indique si oui ou non on veut afficher le débogage. |
| debogage = true |
| ; Indique si oui ou non on veut lancer le chronométrage |
| chronometrage = false |
| +------------------------------------------------------------------------------------------------------+ |
| ; Paramètrage de la base de données. |
| ; bdd_abstraction : abstraction de la base de données. |
| ; bdd_protocole : Protocole de la base de données. |
| ; bdd_serveur : Nom du serveur de bases de données. |
| ; bdd_utilisateur : Nom de l'utilisateur de la base de données. |
| ; bdd_mot_de_passe : Mot de passe de l'utilisateur de la base de données. |
| ; bdd_nom : Nom de la base de données principale. |
| ; bdd_encodage : Encodage de la base de données principale. Normalement le même que l'application mais au format base de |
| ; données : voir ici : http://dev.mysql.com/doc/refman/5.0/en/charset-charsets.html |
| ; et là: http://www.postgresql.org/docs/8.1/static/multibyte.html pour les correspondances |
| bdd_abstraction = pdo |
| bdd_protocole = mysql |
| bdd_serveur = localhost |
| bdd_utilisateur = "root" |
| bdd_mot_de_passe = "" |
| bdd_nom = "tb_cel" |
| bdd_encodage = "utf8" |
| format_XS = 150_100 |
| format_S = 400_300 |
| format_CRS = 300_300 |
| format_M = 600_450 |
| format_L = 800_600 |
| format_XL = 1024_768 |
| format_X2L = 1280_960 |
| format_X3L = 1600_1200 |
| format_CRX2S = 63_63 |
| format_CS = 300_300 |
| format_CXS = 100_100 |
| format_CRXS = 100_100 |
| ; Dossier de base contenant les données d'eFlore (Fichiers TSV et SQL) |
| dossierDonneesEflore = "/home/telabotap/www/eflore/donnees/" |
| ; Dossier de base des images du cel (attention pas de / terminal nécessaire) |
| dossierImages = "/home/apitela/www/images"; |
| ; dossier de stockage temporaire des imagers |
| dossierImagesStockageTemp = "/home/apitela/www/tmp"; |
| tailleMaxImages = 2097152; |
| +------------------------------------------------------------------------------------------------------+ |
| ; Url de base du service fournissant les zones geographiques |
| urlZoneGeoTpl = "http://api.tela-botanica.org/service:eflore:0.1/{projet}/nom-commune?lat={latitude}&lon={longitude}"; |
| urlPaysTpl = "http://api.tela-botanica.org/service:eflore:0.1/osm/zone-admin?lat={latitude}&lon={longitude}"; |
| /branches/v2.21-plantoir/scripts/configurations |
|---|
| New file |
| Property changes: |
| Added: svn:ignore |
| +config.ini |
| /branches/v2.21-plantoir/scripts/framework.defaut.php |
|---|
| New file |
| 0,0 → 1,6 |
| <?php |
| // Inclusion du Framework |
| // Renomer ce fichier en "framework.php" |
| // Indiquer ci-dessous le chemin absolu vers le fichier autoload.inc.php de la bonne version du Framework |
| require_once '/home/www/commun/framework/0.3/Framework.php'; |
| ?> |
| /branches/v2.21-plantoir/scripts/bibliotheque/Conteneur.php |
|---|
| New file |
| 0,0 → 1,100 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Le conteneur encapsule les classes servant aux scripts. |
| * Il gère leur instanciation, ainsi que la récupération des paramètres depuis le fichier de configuration. |
| * |
| * @category CEL |
| * @package Scripts |
| * @subpackage Bibliotheque |
| * @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> |
| */ |
| //TODO : initialiser tous les objets dans le conteneur |
| class Conteneur { |
| protected $parametres = array(); |
| protected $partages = array(); |
| /** |
| * Constructeur de la classe |
| * @param Array $parametres (optionnel) les paramètres additionnels à ajouter à ceux des fichiers de config |
| * */ |
| public function __construct(array $parametres = null) { |
| $this->parametres = is_null($parametres) ? array() : $parametres; |
| } |
| /** |
| * Obtenir un paramètre depuis le tableau de paramètres ou depuis le fichier de config |
| * @param String $cle le nom du paramètre |
| * @return la valeur du paramètre |
| */ |
| public function getParametre($cle) { |
| $valeur = isset($this->parametres[$cle]) ? $this->parametres[$cle] : Config::get($cle); |
| return $valeur; |
| } |
| /** |
| * Obtenir un paramètre depuis le tableau de paramètres ou depuis le fichier de config |
| * et le transformer en tableau s'il est de la forme : "cle=valeur,cle=valeur,..." |
| * @param String $cle le nom du paramètre |
| * @return la valeur du paramètre |
| */ |
| public function getParametreTableau($cle) { |
| $tableau = array(); |
| $parametre = $this->getParametre($cle); |
| if (empty($parametre) === false) { |
| $tableauPartiel = explode(',', $parametre); |
| foreach ($tableauPartiel as $champ) { |
| if (strpos($champ, '=') === false) { |
| $tableau[] = trim($champ); |
| } else { |
| list($cle, $val) = explode('=', $champ); |
| $tableau[trim($cle)] = trim($val); |
| } |
| } |
| } |
| return $tableau; |
| } |
| /** |
| * Enregistrer la valeur d'un paramètre |
| * */ |
| public function setParametre($cle, $valeur) { |
| $this->parametres[$cle] = $valeur; |
| } |
| /** |
| * Permet d'obtenir un objet GestionBdd. |
| */ |
| public function getBdd() { |
| if (!isset($this->partages['Bdd'])){ |
| $this->partages['Bdd'] = new Bdd(); |
| } |
| return $this->partages['Bdd']; |
| } |
| /** |
| * Permet d'obtenir un objet RestClient. |
| */ |
| public function getRestClient() { |
| if (!isset($this->partages['RestClient'])) { |
| $this->partages['RestClient'] = new RestClient(); |
| } |
| return $this->partages['RestClient']; |
| } |
| /** |
| * Permet d'obtenir un objet SquelettePhp. |
| */ |
| public function getSquelettePhp() { |
| if (!isset($this->partages['SquelettePhp'])) { |
| $this->partages['SquelettePhp'] = new SquelettePhp(); |
| } |
| return $this->partages['SquelettePhp']; |
| } |
| } |
| /branches/v2.21-plantoir/scripts/bibliotheque/FichierUtil.php |
|---|
| New file |
| 0,0 → 1,24 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Contient des méthodes utiles pour manipuler les fichiers. |
| * |
| * @category CEL |
| * @package Scripts |
| * @subpackage Bibliotheque |
| * @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 FichierUtil { |
| public static function recupererContenu($chemin) { |
| $contenu = file_get_contents($chemin); |
| if ($contenu === false){ |
| throw new Exception("Impossible d'ouvrir le fichier SQL : $chemin"); |
| } |
| return $contenu; |
| } |
| } |
| /branches/v2.21-plantoir/scripts/bibliotheque/CelScript.php |
|---|
| New file |
| 0,0 → 1,27 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Classe mère des scripts CEL |
| * |
| * @category CEL |
| * @package Scripts |
| * @subpackage Bibliotheque |
| * @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> |
| */ |
| abstract class CelScript extends Script { |
| private $projetNom = null; |
| public function getProjetNom() { |
| return $this->projetNom; |
| } |
| protected function initialiserProjet($projetNom) { |
| $this->projetNom = $projetNom; |
| } |
| } |
| /branches/v2.21-plantoir/scripts/bibliotheque/SqlUtil.php |
|---|
| New file |
| 0,0 → 1,37 |
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Contient des méthodes utiles pour manipuler le SQL. |
| * |
| * @category CEL |
| * @package Scripts |
| * @subpackage Bibliotheque |
| * @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 SqlUtil { |
| public static function extraireRequetes($contenuSql) { |
| $contenuSansCommentaire = self::supprimerCommentaires($contenuSql); |
| $requetesExtraites = preg_split("/;\e*\t*\r*\n/", $contenuSansCommentaire); |
| if (count($requetesExtraites) == 0){ |
| throw new Exception("Aucune requête n'a été trouvée dans le contenu SQL."); |
| } |
| $requetes = array(); |
| foreach ($requetesExtraites as $requete) { |
| if (trim($requete) != '') { |
| $requetes[] = rtrim(trim($requete), ';'); |
| } |
| } |
| return $requetes; |
| } |
| private static function supprimerCommentaires($contenuSql) { |
| return preg_replace('/(## |--).*?\r*\n/', '', $contenuSql); |
| } |
| } |
| /branches/v2.21-plantoir/scripts/cli.php |
|---|
| New file |
| 0,0 → 1,37 |
| <?php |
| // Encodage : UTF-8 |
| // +-------------------------------------------------------------------------------------------------------------------+ |
| /** |
| * Initialise le chargement et l'exécution des scripts |
| * |
| * Lancer ce fichier en ligne de commande avec : |
| * <code>/opt/lampp/bin/php cli.php mon_script -a test</code> |
| * |
| * @category CEL |
| * @package Scripts |
| * @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> |
| */ |
| // Le fichier Framework.php du Framework de Tela Botanica doit être appelée avant tout autre chose dans l'application. |
| // Sinon, rien ne sera chargé. |
| // Chemin du fichier chargeant le framework requis |
| $framework = dirname(__FILE__).DIRECTORY_SEPARATOR.'framework.php'; |
| if (!file_exists($framework)) { |
| $e = "Veuillez paramétrer l'emplacement et la version du Framework dans le fichier $framework"; |
| trigger_error($e, E_USER_ERROR); |
| } else { |
| // Inclusion du Framework |
| require_once $framework; |
| // Ajout d'information concernant cette application |
| Framework::setCheminAppli(__FILE__);// Obligatoire |
| Framework::setInfoAppli(Config::get('info')); |
| // Initialisation et lancement du script appelé en ligne de commande |
| Cli::executer(); |
| } |
| /branches/v2.21-plantoir/scripts/tb_cel.sh |
|---|
| New file |
| 0,0 → 1,54 |
| #!/bin/sh |
| ### BEGIN INIT INFO |
| # Provides: tb_cel |
| # Required-Start: $local_fs $remote_fs |
| # Required-Stop: $local_fs $remote_fs |
| # Should-Start: $all |
| # Should-Stop: $all |
| # Default-Start: 2 3 4 5 |
| # Default-Stop: 0 1 6 |
| # Short-Description: Start/stop scripts maintenance CEL |
| # Description: Start/stop les scripts de maintenance de CEL. |
| ### END INIT INFO |
| #/etc/rc.d/init.d/ |
| # |
| # Aurélien PERONNET [17 avril 2013] |
| # Service de lancement des scripts de maintenance du CEL |
| # |
| case "$1" in |
| start) |
| echo "Demarrage de code_insee_commune :" |
| nohup /usr/local/sbin/code_insee_commune.sh 1>/dev/null 2>/dev/null & |
| ;; |
| stop) |
| echo "Arret de code_insee_commune" |
| PID=`ps -eaf | grep code_insee_commune | grep -v grep | tr -s ' ' | cut -d' ' -f2 | head -n1` |
| kill -9 ${PID} |
| ;; |
| status) |
| echo -n "Voici les PID du processus code_insee_commune :" |
| PID=`ps -eaf | grep code_insee_commune | grep -v grep | tr -s ' ' | cut -d' ' -f2 | head -n1` |
| echo ${PID} |
| ;; |
| *) |
| echo "Usage: {start|stop|status}" |
| exit 1 |
| ;; |
| esac |
| Property changes: |
| Added: svn:eol-style |
| +native |
| \ No newline at end of property |
| Added: svn:executable |
| +* |
| \ No newline at end of property |
| /branches/v2.21-plantoir/scripts/. |
|---|
| New file |
| Property changes: |
| Added: svn:mergeinfo |
| Merged /branches/topic-dbsingleton/scripts:r1720-1764 |
| Merged /branches/v1.8-debroussailleuse/scripts:r1981,1987,1992,2014-2020 |
| Merged /branches/v2.3-faux/scripts:r2228 |
| Merged /branches/v1.7-croissant/scripts:r1855,1879-1880,1885-1886,1917,1923,1983 |
| Added: svn:ignore |
| +framework.php |