Subversion Repositories eFlore/Projets.eflore-projets

<?php
class Images {
        
        private $Bdd;
        private $formats_supportes = array('jpeg');
        private $format_retour_demande = 'jpeg';
        private $format_image_demande = 'M';
        private $num_nom_demande = null;
        private $ref_tax_demande = 'bdtfx';
        
        private $pattern_ref_tax_nn_composes = '/(([a-zA-Z]:((([0-9])+,)*([0-9])+));)*([a-zA-Z]:((([0-9])+,)*([0-9])+))*/i';
        
        public function consulter($ressources, $parametres) {
                $this->bdd_cel = Config::get('bdd_nom');
                $parametres = $this->traiterParametres();               
        
                try {
                        $this->verifierErreurs($parametres);
                        $this->affecterParametres($parametres);
                        $id_image_a_renvoyer = $this->obtenirImageAuHasardPourNumNom($this->ref_tax_demande, $this->num_nom_demande);
                        $this->traiterRetour($id_image_a_renvoyer);
                } catch (Exception $e) {
                        $header = $this->renvoyerHeaderAssocie($e->getCode());
                        $erreurs = $e->getMessage();
                        
                        header($header);
                        $this->envoyerTexteSimple($erreurs);
                        exit;
                }
        }
        
        protected function traiterParametres() {
                $parametres_bruts = array();
                if (!empty($_SERVER['QUERY_STRING'])) {
                        $paires = explode('&', $_SERVER['QUERY_STRING']);
                        foreach ($paires as $paire) {
                                $nv = explode('=', $paire);
                                $nom = urldecode($nv[0]);
                                $valeur = urldecode($nv[1]);
                                $parametres_bruts[$nom] = $valeur;
                        }
                        $parametres_bruts = $this->nettoyerParametres($parametres_bruts);
                }
                return $parametres_bruts;
        }
        
        private function nettoyerParametres(Array $parametres) {
                // Pas besoin d'utiliser urldecode car déjà fait par php pour les clés et valeur de $_GET
                if (isset($parametres) && count($parametres) > 0) {
                        foreach ($parametres as $cle => $valeur) {
                                $verifier = array('NULL', "\n", "\r", "\\", "'", '"', "\x00", "\x1a", ';');
                                $parametres[$cle] = strip_tags(str_replace($verifier, '', $valeur));
                        }
                }
                return $parametres;
        }
        
        private function verifierErreurs($parametres) {
                $erreurs = false;
        
                if (!isset($parametres['masque.nn'])) {
                        $erreurs .= 'Le paramètre masque.nn est obligatoire '."\n";
                } else {
                        if(!preg_match($this->pattern_ref_tax_nn_composes, $parametres['masque.nn'])) {
                                $erreurs .= 'Le paramètre masque.nn est mal formé '."\n";
                        }
                }
        
                if (isset($parametres['retour']) && !$this->retourEstSupporte($parametres['retour'])) {
                        $erreurs .= 'Le type de retour '.$parametres['retour'].' n\'est pas supporté  '."\n";
                }
        
                if (isset($parametres['retour.format']) && !$this->formatEstSupporte($parametres['retour.format'])) {
                        $erreurs .= 'Le type de format '.$parametres['retour.format'].' n\'est pas supporté  '."\n";
                }
        
                if($erreurs != '') {
                        throw new Exception($erreurs, "400");
                }
        }
        
        private function retourEstSupporte($retour = 'image/jpeg') {
                return in_array($retour, $this->formats_supportes);
        }
        
        private function formatEstSupporte($format = 'M') {
        
                $format_supporte = true;
                // cas du format déjà existant (S, M, L etc...)
                $format_supporte = $this->estUnFormatDejaCree($format);
        
                return $format_supporte;
        }
        
        private function estUnFormatDejaCree($format = 'M') {
                $formats = $this->getFormats();
                $format_supporte = isset($formats['format_'.$format]) ? true : false;
        
                return $format_supporte;
        }
        
        private function getFormats() {
                $formats = array();
        
                foreach (Config::get('formats_images') as $param_config => $valeur) {
                        $formats[$param_config] = $valeur;
                }
        
                return $formats;
        }
        
        private function affecterParametres($parametres) {
                // cette fonction est appelée en considérant que les vérifications d'erreurs ont été passées
                // avec succès
                $this->analyserMasqueNumNom($parametres['masque.nn']);
                if(isset($parametres['retour'])) {
                        $this->format_retour_demande =  $parametres['retour'] ;
                }
                if(isset($parametres['retour.format'])) {
                        $this->format_image_demande = $parametres['retour.format'];
                }
        }
        
                private function analyserMasqueNumNom($masque_num_nom) {
                // cette fonction est appelée en considérant que le masque num nom est valide
                        // cas du numero sans référentiel : ref tax par defaut
                if(is_numeric($masque_num_nom)) {
                        $this->num_nom_demande = $masque_num_nom;
                } else {
                // ceci contient potentiellement des formes ref_tax1:nn1,nn2;ref_tax2:nn3,nn4
                $composants_masques = explode(';', $masque_num_nom);
                if (count($composants_masques) > 0) {
                                foreach($composants_masques as $composant_ref_nn) {
                                        $ref_nn = explode(':', $composant_ref_nn);
                                        $this->ref_tax_demande[$composant_ref_nn[0]] = explode(',', $composant_ref_nn[1]);
                                }
                        }
                }
        }
        
        private function obtenirImageAuHasardPourNumNom($ref_tax, $num_nom) {
                //TODO: modifier la requete lors du passage à la nouvelle base de données pour faire quelque chose
                // du numéro nomenclatural + modifier les champs appelés pour le nouveau format
                $requete =      'SELECT  cim.ci_id_image as id_image '.
                                                        'FROM cel_obs_images AS coi '.
                                                        'LEFT JOIN cel_inventory AS ci '.
                                                                'ON (coi.coi_ce_observation = ci.ordre AND coi.coi_ce_utilisateur = ci.identifiant) '.
                                                        'LEFT JOIN cel_images AS cim '.
                                                                'ON (coi.coi_ce_image = cim.ci_id_image AND coi.coi_ce_utilisateur = cim.ci_ce_utilisateur) '.  
                                                        'WHERE ci.transmission = 1 '.
                                                        '       AND num_nom_sel = '.$this->getBdd()->proteger($num_nom).
                                                        '       AND ci.identifiant = cim.ci_ce_utilisateur ';
                        
                $resultat_images = $this->getBdd()->recupererTous($requete);
        
                if (!is_array($resultat_images) || count($resultat_images) <= 0) {
                        $erreur = 'Aucune image ne correspond au numéro numenclatural '.$ref_tax.':'.$num_nom."\n";
                        throw new Exception("404");
                }
        
                $id_image_hasard = $resultat_images[array_rand($resultat_images)]['id_image'];
                return $id_image_hasard;
        }
        
        private function traiterRetour($id_image_a_renvoyer) {
                switch($this->format_retour_demande) {
                        case 'jpeg':
                                $this->renvoyerImageExistanteOuGeneree($id_image_a_renvoyer, $this->format_image_demande);
                                break;
                                        
                        default:
                                $this->renvoyerImageExistanteOuGeneree($id_image_a_renvoyer, 'image/jpeg');
                        break;
                }
        }
        
        private function renvoyerImageExistanteOuGeneree($id_image_a_renvoyer, $format = 'M') {
                if ($this->estUnFormatDejaCree($format)) {
                        $this->renvoyerImageExistante($id_image_a_renvoyer, $format);
                } else {
                        throw new Exception("La génération de formats à la demande n'est pas encore implémentée", "501");
                }
        }
        
        private function renvoyerImageExistante($id_image, $format = 'M') {
                $chemin = $this->functionObtenirCheminImagePourFormat($id_image, $format);
                if(file_exists($chemin)) {
                        header("HTTP/1.0 200 OK");
                        header("Content-type: image/jpeg");
                        echo file_get_contents($chemin);
                        exit;
                } else {
                        throw new Exception("L\'image demandée est introuvable sur le serveur", "404");
                }
        }
        
        public function functionObtenirCheminImagePourFormat($id_image, $format) {
                $nom = $this->convertirIdBddVersNomFichier($id_image, $format);
                $dossier = $this->obtenirDossierPourFormat($id_image,$format);
        
                return $dossier.'/'.$nom;
        }
        
        private function obtenirDossierPourFormat($id, $format) {
                $chemin_base = Config::get('chemin_images');
        
                $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 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;
        }
        
        private function envoyerTexteSimple($chaine) {
                header("Content-type: text/plain");
                echo $chaine;
        }       
                                                                
        private function renvoyerHeaderAssocie($code) {
                switch ($code) {        
                        case '501':
                                $header = "HTTP/1.0 501 Not Implemented";
                        break;
                        
                        case '500':
                                $header = "HTTP/1.0 500 Internal Server Error";
                        break;
                        
                        case '404':
                                $header = "HTTP/1.0 404 Not Found";
                        break;
                        
                        case '400':
                                $header = "HTTP/1.0 400 Bad Request";
                        break;
                                
                        case '200':
                                $header = "HTTP/1.0 200 OK";
                        break;
                        
                        default:
                        break;
                }
        }
        
        /**
        * Méthode de connection à la base de données sur demande.
        * Tous les services web n'ont pas besoin de s'y connecter.
        */
        protected function getBdd() {
                if (! isset($this->Bdd)) {
                        $this->Bdd = new Bdd();
                }
                return $this->Bdd;
        }
}
?>