| 1,292 → 1,312 |
|---|
| <?php |
| |
| require_once('include/extract_metadonnee.php') ; |
| require_once('include/stockage_fichier.php') ; |
| /** |
| |
| Aurelien Peronnet aurelienperonnet@gmail.com 2008 |
| |
| Ce logiciel est r?gi par la licence CeCILL soumise au droit fran?ais et |
| respectant les principes de diffusion des logiciels libres. Vous pouvez |
| utiliser, modifier et/ou redistribuer ce programme sous les conditions |
| de la licence CeCILL telle que diffus?e par le CEA, le CNRS et l'INRIA |
| sur le site "http://www.cecill.info". |
| En contrepartie de l'accessibilit? au code source et des droits de copie, |
| de modification et de redistribution accord?s par cette licence, il n'est |
| offert aux utilisateurs qu'une garantie limit?e. Pour les m?mes raisons, |
| seule une responsabilit? restreinte p?se sur l'auteur du programme, le |
| titulaire des droits patrimoniaux et les conc?dants successifs. |
| |
| A cet ?gard l'attention de l'utilisateur est attir?e sur les risques |
| associ?s au chargement, ? l'utilisation, ? la modification et/ou au |
| d?veloppement et ? la reproduction du logiciel par l'utilisateur ?tant |
| donn? sa sp?cificit? de logiciel libre, qui peut le rendre complexe ? |
| manipuler et qui le r?serve donc ? des d?veloppeurs et des professionnels |
| avertis poss?dant des connaissances informatiques approfondies. Les |
| utilisateurs sont donc invit?s ? charger et tester l'ad?quation du |
| logiciel ? leurs besoins dans des conditions permettant d'assurer la |
| s?curit? de leurs syst?mes et ou de leurs donn?es et, plus g?n?ralement, |
| ? l'utiliser et l'exploiter dans les m?mes conditions de s?curit?. |
| |
| Le fait que vous puissiez acc?der ? cet en-t?te signifie que vous avez |
| pris connaissance de la licence CeCILL, et que vous en avez accept? les |
| termes. |
| |
| */ |
| |
| |
| // in : utf8 |
| // out : utf8 |
| /* |
| * InventoryImage.php |
| * Service recherche et ajout d'image a partir de divers critères |
| * Encodage en entrée : utf8 |
| * Encodage en sortie : utf8 |
| * |
| * Cas d'utilisation : |
| * Service recherche et ajout d'image a partir de divers crit�res |
| * |
| * 1: Le service recoit une image � ajouter � la base de donn�e |
| * 2: Le service recherche l'image correspondant au crit�res demand� |
| * 3: Le service renvoie l'adresse de base de l'image qui permet de la localiser sous ses diff�rents formats (X, M ou L) |
| * @author Aurélien 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> |
| * @version $Id$ |
| */ |
| |
| Class InventoryImage extends DBAccessor { |
| |
| var $config; |
| |
| function InventoryImage($config) { |
| |
| $this->config=$config; |
| } |
| |
| |
| // renvoie l'enregistrement correspond � une image |
| function getElement($uid) |
| Class InventoryImage extends Cel { |
| |
| /** |
| * Méthode appelée avec une requête de type GET. |
| * Renvoie les infos sur l'image correspondant à l'id passé en parametre |
| */ |
| public function getElement($uid) |
| { |
| // uid[0] : utilisateur obligatoire |
| // uid[1] : identifiant image obligatoire |
| |
| // uid[0] : utilisateur obligatoire |
| // uid[1] : identifiant image obligatoire |
| |
| // Controle detournement utilisateur |
| session_start(); |
| $this->controleUtilisateur($uid[0]); |
| session_start(); |
| $this->controleUtilisateur($uid[0]); |
| |
| $DB=$this->connectDB($this->config,'cel_db'); |
| $id_image_protegee = $this->proteger($uid[1]); |
| $requete_selection_image = "SELECT * FROM cel_images WHERE ci_id_image = ".$id_image_protegee; |
| |
| if (isset($uid[0])) |
| { |
| $query="SELECT * FROM cel_images WHERE ci_id_image ='".$DB->escapeSimple($uid[1])."'"; |
| $resultat_selection = $this->executerRequete($requete_selection_image); |
| |
| $image = false; |
| |
| if(count($resultat_selection) > 0) { |
| $image = $resultat_selection[0]; |
| } |
| |
| $res =& $DB->query($query); |
| if (PEAR::isError($res)) { |
| |
| die($res->getMessage()); |
| } |
| |
| $image = $res->fetchrow(DB_FETCHMODE_ASSOC) ; |
| |
| $res = json_encode($image) ; |
| |
| header("content-type: text/json") ; |
| print $res ; |
| exit() ; |
| $this->envoyer($image,'text/html','utf-8',true); |
| } |
| |
| // met � jour les m�tadonn�es d'une image |
| function updateElement($uid,$pairs) |
| /** |
| * Méthode appelée avec une requête de type POST avec un identifiant d'image. |
| * Met a jour l'image correspondant à l'id passé en paramètre avec les valeurs passées dans le post |
| */ |
| public function updateElement($uid,$pairs) |
| { |
| // Controle detournement utilisateur |
| $this->controleUtilisateur($uid[0]); |
| |
| $requete_mise_a_jour_image = 'UPDATE cel_images SET ' ; |
| |
| $champs_a_mettre_a_jour = $this->construireRequeteMajMetaDonnees($pairs); |
| $requete_mise_a_jour_image .= $champs_a_mettre_a_jour; |
| |
| /*$fp = fopen('dump.txt','w+') ; |
| fwrite($fp,print_r($pairs,true)) ; |
| fclose($fp) ;*/ |
| $requete_mise_a_jour_image .= ' WHERE ci_id_image = '.$this->proteger($pairs['ci_id_image']) ; |
| |
| $DB=$this->connectDB($this->config,'cel_db'); |
| |
| $query = 'UPDATE cel_images SET ' ; |
| |
| foreach($pairs as $champ => $valeur) |
| $resultat_mise_a_jour = $this->executerRequete($requete_mise_a_jour_image); |
| |
| $retour = false; |
| |
| if($resultat_mise_a_jour) { |
| $retour = 'OK'; |
| } |
| |
| $this->envoyer($retour); |
| } |
| |
| /** |
| * Assemble la requete de mise à jour des champs de metadonnées |
| * |
| */ |
| private function construireRequeteMajMetaDonnees($valeurs_metadonnees) { |
| |
| $requete_maj_champs = ''; |
| |
| $champs_a_ignorer = array('ci_ce_observation'); |
| |
| foreach($valeurs_metadonnees as $champ => $valeur) |
| { |
| if($champ == 'ci_meta_date') { |
| |
| $date_tab = split('/',$valeur) ; |
| $date = $date_tab[2].'-'.$date_tab[1].'-'.$date_tab[0] ; |
| |
| $query .= $champ.' = "'.$date.'" , ' ; |
| |
| |
| if(!in_array($champ,$champs_a_ignorer)) { |
| if($champ == 'ci_meta_date') { |
| |
| $date_tab = split('/',$valeur) ; |
| $date = $date_tab[2].'-'.$date_tab[1].'-'.$date_tab[0] ; |
| |
| $requete_maj_champs .= $champ.' = "'.$date.'" , ' ; |
| |
| } |
| else { |
| $requete_maj_champs .= $champ.' = '.$this->proteger($valeur).' , ' ; |
| } |
| } |
| else { |
| $query .= $champ.' = "'.$DB->escapeSimple($valeur).'" , ' ; |
| } |
| } |
| |
| $query = rtrim($query," , ") ; |
| |
| $query .= ' WHERE ci_id_image = "'.$DB->escapeSimple($pairs['ci_id_image']).'"' ; |
| |
| $res =& $DB->query($query); |
| |
| if (PEAR::isError($res)) |
| { |
| return false ; |
| } |
| else |
| { |
| echo "OK" ; |
| exit() ; |
| } |
| $requete_maj_champs = rtrim($query," , ") ; |
| |
| return $requete_maj_champs; |
| } |
| |
| |
| // ajoute une image ainsi que ses metadonn�es � la base du carnet |
| /** |
| * Méthode appelée avec une requête de type PUT. |
| * Stocke une image, crée ses miniatures et enregistre ses informations |
| * Renvoie l'identifiant d'image nouvellement crée en cas de succès |
| */ |
| function createElement($pairs) |
| { |
| // Controle detournement utilisateur |
| session_start(); |
| //$this->controleUtilisateur($pairs['identifiant']); |
| $pairs['identifiant'] = 'aurelien@tela-botanica.org'; |
| |
| $manipulateur_image = new ImageRecreation($this->config); |
| |
| $this->controleUtilisateur($pairs['identifiant']); |
| |
| foreach($_FILES as $file) { |
| |
| $infos_fichier = $file ; |
| } |
| |
| $DB=$this->connectDB($this->config,'cel_db'); |
| if($this->ajouterImageSurDdEtBdd($pairs, $infos_fichier)) { |
| |
| // l'upload demande de court-circuiter le fonctionnement normal de JREST |
| // en quittant directement après l'envoi |
| $this->envoyerMessageCreationEffectuee(); |
| exit; |
| } |
| |
| $nouvel_ordre = 0 ; |
| $query_ordre ='SELECT MAX(ci_ordre) FROM cel_images WHERE ci_ce_utilisateur = "'.$DB->escapeSimple($pairs['identifiant']).'"' ; |
| $res =& $DB->query($query_ordre); |
| } |
| |
| /** |
| * Ajout une image dans la base de données et stocke le fichier en fabriquant les miniatures, |
| * renvoie le nouvel id d'image en cas de succès |
| * |
| * @param array $pairs le tableau contenant l'identifiant de l'utilisateur |
| * @param array $infos_fichier les infos sur le fichier à traiter, de la même forme que les |
| * élements du tableau $_FILES de php |
| */ |
| public function ajouterImageSurDdEtBdd($pairs, $infos_fichier) { |
| |
| if (PEAR::isError($res)) |
| { |
| $erreur = 'ERROR : probleme durant le calcul de l\'ordre de l\'image \n' ; |
| die($res->getMessage()); |
| $nouvel_ordre = $this->obtenirNouvelOrdrePourUtilisateur($pairs['identifiant']); |
| |
| if(!$nouvel_ordre) { |
| $message = 'Erreur lors du calcul du nouvel ordre de l\'image'; |
| trigger_error($message, E_USER_ERROR); |
| } |
| |
| $extracteur_metadonnees = new ExtracteurMetadonnees(); |
| $informations_image = $extracteur_metadonnees->extraireMetadonnees($infos_fichier['tmp_name']) ; |
| |
| if(!$informations_image) { |
| $message = 'Erreur lors de l\'extraction des metadonnées'; |
| trigger_error($message, E_USER_ERROR); |
| } |
| |
| // ajout de quelques informations supplémentaire, en sus |
| // des metadonnées dejà extraites |
| $informations_image['ci_ordre'] = $nouvel_ordre ; |
| $informations_image['ci_publiable_eflore'] = 'false' ; |
| $informations_image['ci_nom_original'] = $infos_fichier['name'] ; |
| |
| // le md5 du fichier sert à repérer les images en doublons |
| $informations_image['ci_md5'] = md5_file($infos_fichier['tmp_name']) ; |
| $informations_image['ci_ce_utilisateur'] = $pairs['identifiant'] ; |
| |
| $requete_insertion_infos_image = $this->construireRequeteInsertionImage($informations_image); |
| $resultat_insertion_infos_image = $this->executerRequeteSimple($requete_insertion_infos_image); |
| |
| if(!$resultat_insertion_infos_image) { |
| $message = "Echec de l'insertion dans la base de donnees : " ; |
| trigger_error($message, E_USER_ERROR); |
| } |
| else |
| |
| $id_nouvelle_image = $this->obtenirIdImagePourIdentifiantEtOrdre($pairs['identifiant'], $nouvel_ordre); |
| |
| if(!$id_nouvelle_image) |
| { |
| $row = $res->fetchrow() ; |
| $nouvel_ordre = $row[0] + 1; |
| $message = 'Impossible d\'obtenir le nouvel identifiant de l\'image' ; |
| trigger_error($message, E_USER_ERROR); |
| } |
| |
| if($nouvel_ordre) |
| { |
| $fichier_meta = extraire_metadonnees($infos_fichier['tmp_name']) ; |
| $manipulateur_image = new ImageRecreation($this->config); |
| $fichier_stocke = $manipulateur_image->stockerFichierEtCreerMiniatures($infos_fichier,$id_nouvelle_image) ; |
| |
| if(!$fichier_stocke) { |
| $message = 'Erreur lors du stockage du fichier' ; |
| trigger_error($message, E_USER_ERROR); |
| } |
| else |
| { |
| $erreur = 'ERROR : probleme durant l\'upload de l\'image \n' ; |
| |
| return $id_nouvelle_image; |
| } |
| |
| private function obtenirNouvelOrdrePourUtilisateur($id_utilisateur) { |
| |
| $nouvel_ordre = 0 ; |
| |
| $requete_selection_ordre_max ='SELECT MAX(ci_ordre) as max_ordre FROM cel_images WHERE ci_ce_utilisateur = '.$this->proteger($id_utilisateur) ; |
| $resultat_requete_ordre_max = $this->executerRequete($requete_selection_ordre_max); |
| |
| if($resultat_requete_ordre_max) { |
| $nouvel_ordre = $resultat_requete_ordre_max[0]['max_ordre']; |
| $nouvel_ordre = $nouvel_ordre++; |
| } |
| |
| return $nouvel_ordre; |
| } |
| |
| private function obtenirIdImagePourIdentifiantEtOrdre($id_utilisateur, $ordre) { |
| |
| $id_image = false; |
| |
| $requete_id_image ='SELECT ci_id_image FROM cel_images WHERE ci_ce_utilisateur = '.$this->proteger($id_utilisateur).' AND ci_ordre = '.$ordre ; |
| $resultat_id_image = $this->executerRequete($requete_id_image); |
| |
| $fichier_meta['ci_ordre'] = $nouvel_ordre ; |
| $fichier_meta['ci_publiable_eflore'] = 'false' ; |
| $fichier_meta['ci_nom_original'] = $infos_fichier['name'] ; |
| $fichier_meta['ci_md5'] = md5_file($infos_fichier['tmp_name']) ; |
| $fichier_meta['ci_ce_utilisateur'] = $pairs['identifiant'] ; |
| if(count($resultat_id_image) > 0) |
| { |
| $id_image = $resultat_id_image[0]['ci_id_image']; |
| } |
| |
| return $id_image; |
| } |
| |
| private function construireRequeteInsertionImage($informations_image) { |
| |
| $requete_insertion_image = "INSERT INTO cel_images "; |
| |
| $champs_a_inserer = '' ; |
| $valeurs_a_inserer = '' ; |
| |
| |
| $query_champs = '' ; |
| $query_valeurs = '' ; |
| |
| foreach($fichier_meta as $field => $value) |
| foreach($informations_image as $champ => $valeur) |
| { |
| $query_champs .= $field.',' ; |
| $champs_a_inserer .= $champ.',' ; |
| |
| if(is_null($value)) |
| if(is_null($valeur)) |
| { |
| $query_valeurs .= 'NULL,' ; |
| $valeurs_a_inserer .= 'NULL,' ; |
| } |
| else |
| { |
| $query_valeurs .= '"'.$DB->escapeSimple($value).'",' ; |
| $valeurs_a_inserer .= $this->proteger($valeur).',' ; |
| } |
| } |
| |
| if($fichier_meta['ci_meta_date_time'] != 'NULL') { |
| $champs_a_inserer .= 'ci_meta_date, '; |
| $valeurs_a_inserer .= $this->proteger($fichier_meta['ci_meta_date_time']).','; |
| } |
| |
| $query_champs .= 'ci_meta_date_ajout' ; |
| $query_valeurs .= 'CURRENT_TIMESTAMP()' ; |
| $champs_a_inserer .= 'ci_meta_date_ajout' ; |
| $valeurs_a_inserer .= 'CURRENT_TIMESTAMP()' ; |
| |
| //$query_champs = rtrim($query_champs,',') ; |
| //$query_valeurs = rtrim($query_valeurs,',') ; |
| |
| $query ="INSERT INTO cel_images (".$query_champs.") VALUES (".$query_valeurs.")" ; |
| |
| $res =& $DB->query($query); |
| if (PEAR::isError($res)) { |
| |
| //die($res->getMessage()); |
| $erreur = "ERROR : echec de l'insertion dans la base de donnees : ".$query ; |
| } |
| |
| $query_id ='SELECT ci_id_image FROM cel_images WHERE ci_ce_utilisateur = "'.$DB->escapeSimple($pairs['identifiant']).'" AND ci_ordre = "'.$nouvel_ordre.'"' ; |
| $res =& $DB->query($query_id); |
| |
| if (PEAR::isError($res)) |
| { |
| $erreur = 'ERROR : probleme durant le calcul de l\'id de l\'image \n' ; |
| //die($res->getMessage()); |
| } |
| else |
| { |
| $row = $res->fetchrow() ; |
| $id = $row[0] ; |
| } |
| $requete_insertion_image .= "(".$champs_a_inserer.") VALUES (".$valeurs_a_inserer.")" ; |
| |
| if(isset($id)) |
| { |
| $fichier = array('name' => $infos_fichier['name'] , 'type' => $infos_fichier['type'] , 'size' => $infos_fichier['size'] , 'tmp_name' => $infos_fichier['tmp_name'] ) ; |
| $fichier_stocke = $manipulateur_image->stockerFichierUploadeEtCreerMiniatures($fichier,$id) ; |
| // l'upload demande de court-circuiter le fonctionnement normal de JREST |
| header('HTTP/1.0 200 Created'); |
| echo "OK" ; |
| exit() ; |
| } |
| else |
| { |
| $erreur = 'ERROR : probleme durant l\'ajout des metadonnees \n' ; |
| exit ; |
| } |
| |
| return $requete_insertion_image; |
| } |
| |
| private function envoyerMessageCreationEffectuee() { |
| |
| header('HTTP/1.0 200 Created'); |
| exit() ; |
| } |
| |
| // supprime une image et ses metadonn�es associ�es de la base du carnet |
| /** |
| * Méthode appelée avec une requête de type DELETE. |
| * Supprime les infos sur l'image et le fichier correspondant à l'id passé en parametre |
| */ |
| function deleteElement($uid){ |
| |
| // uid[0] : utilisateur obligatoire |
| // uid[1] : identifiant(s) image(s) obligatoire(s) |
| // uid[0] : utilisateur obligatoire |
| // uid[1] : identifiant image(s) obligatoire(s) |
| |
| // Controle detournement utilisateur |
| // Controle detournement utilisateur |
| session_start(); |
| $this->controleUtilisateur($uid[0]); |
| |
| $DB=$this->connectDB($this->config,'cel_db'); |
| |
| $id = $uid[1] ; |
| |
| if (isset($uid[1])) { |
| $query="DELETE FROM cel_images WHERE ci_id_image in (".$DB->escapeSimple($uid[1]) .")"; |
| $query_sup_lien = "DELETE FROM cel_obs_images WHERE coi_ce_image in (".$DB->escapeSimple($id) .")"; |
| if(!isset($uid[1]) || !$this->EstUneSuiteIdentifiantsImage($uid[1])) { |
| return; |
| } |
| |
| $ids_images = $uid[1]; |
| |
| $res =& $DB->query($query); |
| |
| if (PEAR::isError($res)) { |
| die($res->getMessage()); |
| $requete_suppression_images = "DELETE FROM cel_images WHERE ci_id_image in (".$ids_images.")"; |
| $requete_suppression_lien_images_obs = "DELETE FROM cel_obs_images WHERE coi_ce_image in (".$ids_images.")"; |
| |
| $resultat_suppression_image = $this->executerRequeteSimple($requete_suppression_images); |
| $resultat_suppression_lien_images_obs = $this->executerRequeteSimple($requete_suppression_lien_images_obs); |
| |
| if(!$resultat_suppression_image) { |
| $message = 'Erreur lors de la suppression de l\'image' ; |
| trigger_error($message, E_USER_ERROR); |
| } |
| else |
| { |
| $res =& $DB->query($query_sup_lien); |
| if(PEAR::isError($res)) |
| { |
| die($res->getMessage()); |
| } |
| |
| $manipulateur_image = new ImageRecreation($this->config); |
| $manipulateur_image->detruireImageSurDisque($id); |
| if(!$resultat_suppression_lien_images_obs) { |
| $message = 'Erreur lors de la suppression des observations associées à l\'image' ; |
| trigger_error($message, E_USER_ERROR); |
| } |
| |
| echo "OK" ; |
| exit() ; |
| } |
| $manipulateur_image = new ImageRecreation($this->config); |
| $destruction_fichier_image = $manipulateur_image->detruireImageSurDisque($id); |
| |
| $this->envoyer('OK'); |
| } |
| |
| private function estUneSuiteIdentifiantsImage($chaine) { |
| |
| // un ensemble d'identifiants est une suite d'identifiants séparés par des virgules |
| // sans virgule terminale |
| $reg_exp = "/^(([0-9])+,)*([0-9])+$/"; |
| |
| return preg_match($reg_exp, $chaine); |
| |
| } |
| |
| } |
| ?> |