/[openfoncier]/trunk/obj/utils.class.php
ViewVC logotype

Diff of /trunk/obj/utils.class.php

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 943 by fmichon, Fri Nov 30 15:25:27 2012 UTC revision 2605 by softime, Thu Dec 12 18:00:35 2013 UTC
# Line 59  class utils extends application { Line 59  class utils extends application {
59    
60      var $om_utilisateur = array();      var $om_utilisateur = array();
61      var $user_is_instr = NULL;      var $user_is_instr = NULL;
62        var $user_is_service = NULL;
63        var $user_is_admin = NULL;
64      var $user_is_service_ext = NULL;      var $user_is_service_ext = NULL;
65        var $user_is_qualificateur = NULL;
66        var $user_is_chef = NULL;
67        var $user_is_divisionnaire = NULL;
68        var $user_is_service_int = NULL;
69    
70      /**      /**
71       * Méthode de récupération des informations de l'utilisateur connecté.       * Méthode de récupération des informations de l'utilisateur connecté.
# Line 74  class utils extends application { Line 80  class utils extends application {
80              "FROM ".DB_PREFIXE."om_utilisateur WHERE login = '".$_SESSION['login']."'";              "FROM ".DB_PREFIXE."om_utilisateur WHERE login = '".$_SESSION['login']."'";
81              $resUser=$this->db->query($sqlUser);              $resUser=$this->db->query($sqlUser);
82              $this->addToLog("getUserInfos(): db->query(\"".$sqlUser."\");", VERBOSE_MODE);              $this->addToLog("getUserInfos(): db->query(\"".$sqlUser."\");", VERBOSE_MODE);
83              $this->isDatabaseError($resUser);              if ( database::isError($resUser)){
84                    die();
85                }
86              $this->om_utilisateur=&$resUser->fetchRow(DB_FETCHMODE_ASSOC);              $this->om_utilisateur=&$resUser->fetchRow(DB_FETCHMODE_ASSOC);
87    
88                // Récupère le profil et test si c'est un
89                $sqlProfil = "SELECT libelle FROM ".DB_PREFIXE."om_profil WHERE om_profil = ".$this->om_utilisateur['om_profil'];
90                $resProfil=$this->db->getOne($sqlProfil);
91                $this->addToLog("getUserInfos(): db->getOne(\"".$sqlProfil."\");", VERBOSE_MODE);
92                if (database::isError($resProfil)){
93                    die();
94                }
95                // Sauvegarde le libelle du profil
96                $this->om_utilisateur["libelle_profil"] = $resProfil;
97    
98                // si c'est un administrateur technique
99                // XXX Mauvaise méthode, il faut utiliser isAccredited
100                if ($resProfil == "ADMINISTRATEUR TECHNIQUE"
101                    || $resProfil == "ADMINISTRATEUR FONCTIONNEL") {
102                    $this->user_is_admin = true;
103                } else {
104                    $this->user_is_admin = false;
105                }
106    
107                //si c'est un service externe
108                if ($resProfil == "SERVICE CONSULTÉ") {
109                    $this->user_is_service_ext = true;
110                } else {
111                    $this->user_is_service_ext = false;
112                }
113    
114                //si c'est un service interne
115                if ($resProfil == "SERVICE CONSULTÉ INTERNE") {
116                    $this->user_is_service_int = true;
117                } else {
118                    $this->user_is_service_int = false;
119                }
120    
121                // si c'est un qualificateur
122                if ($resProfil == "QUALIFICATEUR") {
123                    $this->user_is_qualificateur = true;
124                } else {
125                    $this->user_is_qualificateur = false;
126                }
127    
128                // si c'est un chef de service
129                if ($resProfil == "CHEF DE SERVICE") {
130                    $this->user_is_chef = true;
131                } else {
132                    $this->user_is_chef = false;
133                }
134    
135                // si c'est un divisionnaire
136                if ($resProfil == "DIVISIONNAIRE") {
137                    $this->user_is_divisionnaire = true;
138                } else {
139                    $this->user_is_divisionnaire = false;
140                }
141                            
142              // Récupération des infos instructeur              // Récupération des infos instructeur
143              $sqlInstr = "SELECT instructeur.instructeur, instructeur.nom, instructeur.telephone,              $sqlInstr = "SELECT instructeur.instructeur, instructeur.nom, instructeur.telephone,
# Line 84  class utils extends application { Line 146  class utils extends application {
146              "WHERE instructeur.om_utilisateur = ".$this->om_utilisateur['om_utilisateur'];              "WHERE instructeur.om_utilisateur = ".$this->om_utilisateur['om_utilisateur'];
147              $resInstr=$this->db->query($sqlInstr);              $resInstr=$this->db->query($sqlInstr);
148              $this->addToLog("getUserInfos(): db->query(\"".$sqlInstr."\");", VERBOSE_MODE);              $this->addToLog("getUserInfos(): db->query(\"".$sqlInstr."\");", VERBOSE_MODE);
149              $this->isDatabaseError($resInstr);              if ( database::isError($resInstr)){
150                    die();
151                }
152              $tempInstr=&$resInstr->fetchRow(DB_FETCHMODE_ASSOC);              $tempInstr=&$resInstr->fetchRow(DB_FETCHMODE_ASSOC);
153              // Si il y a un resultat c'est un instructeur              // Si il y a un resultat c'est un instructeur
154              if(count($tempInstr)>0) {              if(count($tempInstr)>0) {
# Line 94  class utils extends application { Line 158  class utils extends application {
158                  $this->user_is_instr=false;                  $this->user_is_instr=false;
159              }              }
160                            
161              // Récupération des infos de services ext consultés              // Récupération des infos de services consultés
162              $sqlServExt = "SELECT service.service, service.abrege, service.libelle ".              $sqlServ = "SELECT service.service, service.abrege, service.libelle ".
163              "FROM ".DB_PREFIXE."service ".              "FROM ".DB_PREFIXE."service ".
164              "INNER JOIN ".DB_PREFIXE."lien_service_om_utilisateur ON lien_service_om_utilisateur.service=service.service ".              "INNER JOIN ".DB_PREFIXE."lien_service_om_utilisateur ON lien_service_om_utilisateur.service=service.service ".
165              "WHERE lien_service_om_utilisateur.om_utilisateur = ".$this->om_utilisateur['om_utilisateur'];              "WHERE lien_service_om_utilisateur.om_utilisateur = ".$this->om_utilisateur['om_utilisateur'];
166              $resServExt=$this->db->query($sqlServExt);              $resServ=$this->db->query($sqlServ);
167              $this->addToLog("getUserInfos(): db->query(\"".$sqlServExt."\");", VERBOSE_MODE);              $this->addToLog("getUserInfos(): db->query(\"".$sqlServ."\");", VERBOSE_MODE);
168              $this->isDatabaseError($resServExt);              if ( database::isError($resServ)){
169                    die();
170                }
171                            
172              while ($tempServExt=&$resServExt->fetchRow(DB_FETCHMODE_ASSOC)) {              while ($tempServ=&$resServ->fetchRow(DB_FETCHMODE_ASSOC)) {
173                  $this->om_utilisateur['service'][]=$tempServExt;                  $this->om_utilisateur['service'][]=$tempServ;
174              }              }
175              // Si il y a un resultat c'est un utilisateur de service              // Si il y a un resultat c'est un utilisateur de service
176              if(isset($this->om_utilisateur['service'])) {              if(isset($this->om_utilisateur['service'])) {
177                  $this->user_is_service_ext=true;                  $this->user_is_service=true;
178              } else {              } else {
179                  $this->user_is_service_ext=false;                  $this->user_is_service=false;
180              }              }
181          }          }
182      }      }
183    
184      /**      /**
185       * getter user_is_service_ext       * getter user_is_service
186       */       */
187      function isUserServiceExt() {      function isUserService() {
188          //          //
189          if (is_null($this->user_is_service_ext)) {          if (is_null($this->user_is_service)) {
190              //              //
191              $this->getUserInfos();              $this->getUserInfos();
192          }          }
193          //          //
194          return $this->user_is_service_ext;          return $this->user_is_service;
195      }      }
196    
197      /**      /**
# Line 141  class utils extends application { Line 207  class utils extends application {
207          return $this->user_is_instr;          return $this->user_is_instr;
208      }      }
209    
210        function isUserAdministrateur() {
211            //
212            if (is_null($this->user_is_admin)) {
213                //
214                $this->getUserInfos();
215            }
216            //
217            return $this->user_is_admin;
218        }
219    
220        /**
221         * getter user_is_service_ext
222         */
223        function isUserServiceExt() {
224            //
225            if (is_null($this->user_is_service_ext)) {
226                //
227                $this->getUserInfos();
228            }
229            //
230            return $this->user_is_service_ext;
231        }
232    
233        /**
234         * getter user_is_service_int
235         */
236        function isUserServiceInt() {
237            //
238            if (is_null($this->user_is_service_int)) {
239                //
240                $this->getUserInfos();
241            }
242            //
243            return $this->user_is_service_int;
244        }
245    
246        /**
247         * getter user_is_qualificateur
248         */
249        function isUserQualificateur() {
250            //
251            if (is_null($this->user_is_qualificateur)) {
252                //
253                $this->getUserInfos();
254            }
255            //
256            return $this->user_is_qualificateur;
257        }
258    
259        /**
260         * getter user_is_chef
261         */
262        function isUserChef() {
263            //
264            if (is_null($this->user_is_chef)) {
265                //
266                $this->getUserInfos();
267            }
268            //
269            return $this->user_is_chef;
270        }
271    
272        /**
273         * getter user_is_divisionnaire
274         */
275        function isUserDivisionnaire() {
276            //
277            if (is_null($this->user_is_divisionnaire)) {
278                //
279                $this->getUserInfos();
280            }
281            //
282            return $this->user_is_divisionnaire;
283        }
284    
285      // Ajout de variables de session contenant la division pour permettre une      // Ajout de variables de session contenant la division pour permettre une
286      // utilisation plus efficace dans les requetes      // utilisation plus efficace dans les requetes
287      function triggerAfterLogin($utilisateur = NULL) {      function triggerAfterLogin($utilisateur = NULL) {
# Line 152  class utils extends application { Line 293  class utils extends application {
293          WHERE instructeur.om_utilisateur='".$utilisateur["om_utilisateur"]."'";          WHERE instructeur.om_utilisateur='".$utilisateur["om_utilisateur"]."'";
294          $res = $this->db->query($sql);          $res = $this->db->query($sql);
295          $this->addToLog("triggerAfterLogin(): db->query(\"".$sql."\");", VERBOSE_MODE);          $this->addToLog("triggerAfterLogin(): db->query(\"".$sql."\");", VERBOSE_MODE);
296          $this->isDatabaseError($res);          if ( database::isError($res)){
297                die();
298            }
299          $row = $res->fetchrow(DB_FETCHMODE_ASSOC);          $row = $res->fetchrow(DB_FETCHMODE_ASSOC);
300          //          //
301          if (isset($row["division"]) && $row["division"] != NULL) {          if (isset($row["division"]) && $row["division"] != NULL) {
# Line 177  class utils extends application { Line 320  class utils extends application {
320    
321      // }}}      // }}}
322    
323      // {{{ SURCHARGES POUR LE FONCTIONNEMENT DES REQUETES REST      
324        function getDivisionFromDossier($dossier) {
325            //
326            $sql = "select division from ".DB_PREFIXE."dossier ";
327            $sql .= " where dossier='".$dossier."'";
328            //
329            $division = $this->db->getOne($sql);
330            $this->addToLog("getDivisionFromDossier(): db->getone(\"".$sql."\")", VERBOSE_MODE);
331            database::isError($division);
332            //
333            return $division;
334        }
335    
336        // {{{ GESTION DES FICHIERS
337        
338      /**      /**
      * Cette méthode permet de vérifier si l'utilisateur est autorisé ou non à  
      * accéder à un élément et permet d'agir en conséquence  
339       *       *
      * @param  
      * @return mixed  
340       */       */
341      function isAuthorized($obj = NULL, $operator = "AND") {      function notExistsError ($explanation = NULL) {
342            // message
343            $message_class = "error";
344            $message = _("Cette page n'existe pas.");
345            $this->addToMessage ($message_class, $message);
346          //          //
347          if ($obj == NULL) {          $this->setFlag(NULL);
348              $obj = $this->right;          $this->display();
349          }          
350          //          //
351          if ($obj == NULL) {          die();
352              return true;      }
353          }      
354         // }}}
355          // L'utilisateur n'est pas autorisé à accéder à l'élément      /**
356          if (!$this->isAccredited($obj, $operator)) {       * Retourne le statut du dossier d'instruction
357         * @param string $idx Identifiant du dossier d'instruction
358              //       * @return string Le statut du dossier d'instruction
359              $message_class = "error";       */
360              $message = _("Droits insuffisants. Vous n'avez pas suffisament de ".      function getStatutDossier($idx){
361                           "droits pour acceder a cette page.");          
362              $this->addToMessage($message_class, $message);          $statut = '';
363            
364              //          //Si l'identifiant du dossier d'instruction fourni est correct
365              $this->setFlag(NULL);          if ( $idx != '' ){
366              if (!defined('REST_REQUEST')) {              
367                  $this->display();              //On récupère le statut de l'état du dossier à partir de l'identifiant du
368                //dossier d'instruction
369                $sql = "SELECT etat.statut
370                    FROM ".DB_PREFIXE."dossier
371                    LEFT JOIN
372                        ".DB_PREFIXE."etat
373                        ON
374                            dossier.etat = etat.etat
375                    WHERE dossier ='".$idx."'";
376                $statut = $this->db->getOne($sql);
377                $this->addToLog("getStatutDossier() : db->getOne(\"".$sql."\")", VERBOSE_MODE);
378                if ( database::isError($statut)){
379                    die();
380              }              }
   
             // Arrêt du script  
             die();  
   
381          }          }
382            return $statut;
         // L'utilisateur est autorisé à accéder à l'élément  
         return true;  
   
383      }      }
384    
385        /**
386         * Formate le champ pour le type Timestamp
387         * @param  date  $date_str          Date
388         * @param  boolean $show            Format pour l'affichage
389         * @return mixed                    False si le traitement échoue ou la date formatée
390         */
391        function formatTimestamp ($date_str, $show = true) {
392    
393            // Sépare la date et l'heure
394            $date = explode(" ", $date_str);
395            if (count($date) != 2) {
396                return false;
397            }
398    
399            // Date en BDD
400            $date_db = explode ('-', $date[0]);
401                    // Date en affichage
402            $date_show = explode ('/', $date[0]);
403    
404      /**          // Contrôle la composition de la date
405       *          if (count ($date_db) != 3 and count ($date_show) != 3) {
406       */              return false;
407      function setDatabaseConfig() {          }
408    
409          // On recupere la liste des cles du tableau associatif de configuration          if (count ($date_db) == 3) {
410          // de la connexion aux bases de donnees              // Vérifie que c'est une date valide
411          $database_keys = array_keys($this->database);              if (!checkdate($date_db[1], $date_db[2], $date_db[0])) {
412          // Si il y a plusieurs cles                  return false;
413          if (count($database_keys) != 0) {              }
414              // On configure la premiere par defaut              // Si c'est pour l'affichage de la date
415              $coll = $database_keys[0];              if ($show == true) {
416          } else { // Si il n'y a aucune cle                  return $date_db [2]."/".$date_db [1]."/".$date_db [0]." ".$date[1];
417              // Aucune base n'est configuree dans le fichier de configuration              } else {
418              // donc on affiche un message d'erreur                  return $date[0];
419              $class = "error";              }
             $message = _("Erreur de configuration. Contactez votre administrateur.");  
             $this->addToMessage($class, $message);  
             // Debug  
             $this->addToLog("setDatabaseConfig(): ERR", DEBUG_MODE);  
             $this->addToLog("ERR: "._("Aucune entree dans le fichier de configuration"), DEBUG_MODE);  
             // On affiche la structure de la page  
             $this->setFlag(NULL);  
             $this->display();  
             // On arrete le traitement en cours  
             die();  
420          }          }
421    
422          // Si la variable coll (representant la cle de la base sur laquelle          //
423          // nous travaillons) n'est pas en variable SESSION ou est en variable          if (count ($date_show) == 3) {
424          // SESSION mais n'existe pas dans les cles du tableau associatif de              // Vérifie que c'est une date valide
425          // configuration de la connexion aux bases de donnees              if (!checkdate($date_show[1], $date_show[0], $date_show[2])) {
426          if (!isset($_SESSION['coll']) or                  return false;
427              (isset($_SESSION['coll']) and              }
428               !isset($this->database[$_SESSION['coll']]))) {              // Si c'est pour l'affichage de la date
429              // On configure la premiere par defaut              if ($show == true) {
430              $_SESSION['coll'] = $coll;                  return $date[0];
431          } else {              } else {
432              // On recupere la cle du tableau associatif de configuration de la                  return $date_show [2]."-".$date_show [1]."-".$date_show [0]." ".$date[1];
433              // connexion aux bases de donnees correspondante a la base de              }
434              // donnees sur laquelle nous travaillons  
             $coll = $_SESSION['coll'];  
435          }          }
436            return false;
437    
         // On renvoi le tableau de parametres pour la connexion a la base  
         $this->database_config = $this->database[$coll];  
438      }      }
439    
440            /**
441          /**       * Permet de calculer la liste des parcelles à partir de la chaîne passée en paramètre
442       * Cette méthode permet de se connecter à la base de données       * et la retourner sous forme d'un tableau associatif
443       * @return void       *
444       */       * @param  string $strParcelles chaîne de la parcelles
445      function connectDatabase() {       * @return array (array(quartier, section, parcelle), ...)
446          // On inclus la classe d'abstraction de base de donnees       */
447          require_once PATH_OPENMAIRIE."om_database.class.php";      function parseParcelles($strParcelles) {
448          // On recupere le tableau de parametres pour la connexion a la base          
449          $this->setDatabaseConfig();          // Séparation des lignes
450          // On fixe les options          $references = explode(";", $strParcelles);
451          $options = array(          $liste_parcelles = array();
452              'debug' => 2,          
453              'portability' => DB_PORTABILITY_ALL,          // On boucle sur chaque ligne pour ajouter la liste des parcelles de chaque ligne
454          );          foreach ($references as $parcelles) {
455          // Instanciation de l'objet connexion a la base de donnees              
456          $db = database::connect($this->database_config, $options);              // On transforme la chaîne de la ligne de parcelles en tableau
457          // Logger              $ref = str_split($parcelles);
458          $this->addToLog("connectDatabase(): "._("Tentative de connexion au SGBD"), EXTRA_VERBOSE_MODE);              // Les 1er caractères sont numériques
459          // Traitement particulier de l'erreur en cas d'erreur de connexion a la              $num = true;
460          // base de donnees              
461          if (database::isError($db, true)) {              // Tableau des champs de la ligne de références cadastrales
462              // Deconnexion de l'utilisateur              $reference_tab = array();
             $this->logout();  
             // On affiche la page de login a l'ecran  
             $this->setFlag("login");  
             // On affiche un message d'erreur convivial pour l'utilisateur  
             $class = "error";  
             $message = _("Erreur de base de donnees. Contactez votre administrateur.");  
             $this->addToMessage($class, $message);  
             // On affiche la page  
             if (!defined('REST_REQUEST')) {  
                 $this->display();  
             }  
             // On arrete le script  
             die();  
         } else {  
             // On affecte la resource a l'attribut de la classe du meme nom  
             $this->db = $db;  
             // Logger  
             $this->addToLog("connectDatabase(): Connexion [".$this->database_config["phptype"]."] '".$this->database_config['database']."' OK", EXTRA_VERBOSE_MODE);  
   
             // Compatibilite anterieure (deprecated)  
             $this->phptype = $this->database_config["phptype"];  
             $this->formatdate = $this->database_config["formatdate"];  
             $this->schema = $this->database_config["schema"];  
   
             // Definition des constantes pour l'acces aux informations de la base  
             // donnees facilement.  
463              $temp = "";              $temp = "";
464              if ($this->database_config["schema"] != "") {              foreach ($ref as $carac) {
465                  $temp = $this->database_config["schema"].".";                  
466                    // Permet de tester si le caractère courant est de même type que le précédent
467                    if(is_numeric($carac) === $num) {
468                        $temp .= $carac;
469                    } else {
470                        // Bascule
471                        $num = !$num;
472                        // On stock le champ
473                        $reference_tab[] = $temp;
474                        // re-init de la valeur temporaire pour le champ suivant
475                        $temp = $carac;
476                    }
477                }
478                // Stockage du dernier champ sur lequel il n'y a pas eu de bascule
479                $reference_tab[] = $temp;
480                // Calcul des parcelles
481                $quartier = $reference_tab[0];
482                $sect = $reference_tab[1];
483    
484                $ancien_ref_parc = "";
485                for ($i=2; $i < count($reference_tab); $i+=2) {
486                    $parc["quartier"] = $quartier;
487                    // Met en majuscule si besoin
488                    $parc["section"] = strtoupper($sect);
489                    if( $ancien_ref_parc == "" OR $reference_tab[$i-1] == "/") {
490                        // 1ere parcelle ou parcelle individuelle
491                        // Compléte par des "0" le début de la chaîne si besoin
492                        $parc["parcelle"] = str_pad($reference_tab[$i], 4, "0", STR_PAD_LEFT);
493                        // Ajout d'une parcelle à la liste
494                        $liste_parcelles[] = $parc;
495                    } elseif ($reference_tab[$i-1] == "A") {
496                        // Interval de parcelles
497                        for ($j=$ancien_ref_parc+1; $j <= $reference_tab[$i]; $j++) {
498                            // Compléte par des "0" le début de la chaîne si besoin
499                            $parc["parcelle"] = str_pad($j, 4, "0", STR_PAD_LEFT);
500                            // Ajout d'une parcelle à la liste
501                            $liste_parcelles[] = $parc;
502                        }
503                    }
504                    //Gestion des erreurs
505                    else{
506                        
507                        echo _("Une erreur de formattage a ete detecte dans la reference cadastrale du dossier ").$this->row['dossier'];
508                    }
509                    // Sauvegarde de la référence courante de parcelle
510                    $ancien_ref_parc = $reference_tab[$i];
511              }              }
             $temp = $temp.$this->database_config["prefixe"];  
             define("DB_PREFIXE", $temp);  
             define("FORMATDATE", $this->database_config["formatdate"]);  
   
             // Definition des constantes pour l'acces aux informations de la base  
             // donnees facilement.  
             define("OM_DB_FORMATDATE", $this->database_config["formatdate"]);  
             define("OM_DB_PHPTYPE", $this->database_config["phptype"]);  
             define("OM_DB_DATABASE", $this->database_config["database"]);  
             define("OM_DB_SCHEMA", $this->database_config["schema"]);  
             define("OM_DB_TABLE_PREFIX", $this->database_config["prefixe"]);  
512          }          }
513    
514            return $liste_parcelles;
515      }      }
516    
   
517      /**      /**
518       *       * Formate les parcelles en ajoutant le code impôt
519       *       * @param  array    $liste_parcelles   Tableau des parcelles
520         * @return string                      Liste des parcelles formatées
521       */       */
522      function isDatabaseError($dbobj = NULL, $return = false) {      function formatParcelleToSend($liste_parcelles) {
523    
524          //          //
525          if (database::isError($dbobj, $return)) {          $wParcelle = array();
   
             if ($return == true) {  
   
                 //  
                 return true;  
526    
527              }          //Formatage des références cadastrales pour l'envoi
528            foreach ($liste_parcelles as $value) {
529              //                  
530              $class = "error";              // On ajoute les données dans le tableau que si quartier + section + parcelle
531              $message = _("Erreur de base de donnees. Contactez votre administrateur.");              // a été fourni
532              $this->addToMessage($class, $message);              if ($value["quartier"] !== ""
533                    && $value["section"] !== ""
534              // Logger                  && $value["parcelle"] !== ""){
535              $this->addToLog("isDatabaseError(): ".$dbobj->getDebugInfo(), DEBUG_MODE);                  
536              $this->addToLog("isDatabaseError(): ".$dbobj->getMessage(), DEBUG_MODE);                  //On récupère le code impôt de l'arrondissement
537                    $arrondissement = $this->getCodeImpotByQuartier($value["quartier"]);
538                    
539                    //On ajoute la parcelle, si un arrondissement a été trouvé
540                    if ($arrondissement!=="") {
541                        //
542                        $wParcelle[] = $arrondissement.$value["quartier"]." ".
543                            $value["section"].$value["parcelle"];
544    
545              //                  }
             $this->setFlag(NULL);  
             if (!defined('REST_REQUEST')) {  
                 $this->display();  
                 //  
                 die();  
546              }              }
   
547          }          }
548    
549          //          //
550          return false;          return $wParcelle;
   
551      }      }
       
552    
           
553      /**      /**
554       *       * Récupère le code impôt par rapport au quartier
555       * @return void       * @param  string $quartier Numéro de quartier
556       */       * @return string           Code impôt
557      function displayMessage($class = "", $message = "") {       */
558          if (!defined('REST_REQUEST')) {      function getCodeImpotByQuartier($quartier) {
559              $this->m->displayMessage($class, $message);  
560            $arrondissement = "";
561    
562            // Si le quartier fournis est correct
563            if ($quartier != "") {
564    
565                // Requête SQL
566                $sql = "SELECT
567                            arrondissement.code_impots
568                        FROM
569                            ".DB_PREFIXE."arrondissement
570                        LEFT JOIN
571                            ".DB_PREFIXE."quartier
572                            ON
573                                quartier.arrondissement = arrondissement.arrondissement
574                        WHERE
575                            quartier.code_impots = '".$quartier."'";
576                $this->addToLog("getCodeImpotByQuartier() : db->getOne(\"".$sql."\")", VERBOSE_MODE);
577                $arrondissement = $this->db->getOne($sql);
578                $this->isDatabaseError($arrondissement);
579          }          }
580    
581            // Retour
582            return $arrondissement;
583      }      }
584    
585      // }}}      /**
586         * Vérification des paramètres
587         */
588        function checkParams() {
589            parent::checkParams();
590    
591      // {{{ GESTION DES FICHIERS          (isset($this->config['path_scan']) ? "" : $this->config['path_scan'] = '../trs/numerisation/');
592            
593            $default_sig_elyx = array(
594                'wsdl' => '../tests/wsurbanisme.wsdl',
595                'login' => 'sig',
596                'password' => 'sig',
597            );
598            (isset($this->config['sig_elyx']) ? "" : $this->config['sig_elyx'] = $default_sig_elyx);
599        }
600    
601      /**      /**
602       * Méthode de création de répertoire dans le dossier /trs correspondant       * Retourne true si tous les paramètres du SIG externe ont bien été définis
603       * à l'id du tableau de configuration de la connexion à la base de donnée       * @return bool true/false
604       * (dyn/database.inc.php)       */
605       **/      public function issetSIGParameter() {
606      function createFolder($folder) {          if($this->getParameter("sig_web_server") != NULL AND
607          if (!mkdir($this->getPathFolderTrs().$folder)) {              $this->getParameter("sig_web_server") != "" AND
608              // message              $this->getParameter("sig_couche_emprise_dossier") != NULL AND
609              $message_class = "error";              $this->getParameter("sig_couche_emprise_dossier") != "" AND
610              $message = _("Echec lors de la creation du repertoires.");              $this->getParameter("sig_couche_affichage_dossier") != NULL AND
611              $this->addToMessage ($message_class, $message);              $this->getParameter("sig_couche_affichage_dossier") != "" AND
612                $this->getParameter("sig_couche_affichage_parcelle") != NULL AND
613                $this->getParameter("sig_couche_affichage_parcelle") != "") {
614                return true;
615            } else {
616                return false;
617          }          }
618      }      }
       
     /*  
      * Methode permettant de lister tous les fichiers d'un dossier  
      */  
     function getFolderFileList($id_folder) {  
619    
620          $file_list = array();      /**
621          if(is_dir($this->getPathFolderTrs().$id_folder)) {       * Permet de vérifier que des champs existe dans une table
622              if($dossier = opendir($this->getPathFolderTrs().$id_folder)) {       * @param  array  $list_fields Liste des champs à tester
623                         * @param  string $table       Table où les champs doivent exister
624                  while(false !== ($fichier = readdir($dossier))) {       * @return mixed               Retourne les champs qui n'existent pas
625                         *                             ou true
626                      if($fichier != '.' && $fichier != '..' && !is_dir($fichier)) {       */
627                          $file_list[]=array( $fichier,      public function check_field_exist($list_fields, $table) {
628                              filemtime($this->getPathFolderTrs().$id_folder."/".$fichier));  
629                      } // On ferme le if (qui permet de ne pas afficher index.php, etc.)          // Requête SQL pour récupérer le nom des colonnes
630                            $sql = "SELECT column_name
631                  } // On termine la boucle                  FROM information_schema.columns
632                            WHERE table_schema = '".substr(DB_PREFIXE, 0, -1)."'
633                  closedir($dossier);                  AND table_name = '".$table."'
634                        ORDER BY ordinal_position";
635              } else {          $this->addToLog("check_field_exist() : db->query(\"".$sql."\")", VERBOSE_MODE);
636                  $this->displayMessage("error", _("Les documents du repertoire ne sont pas accessible."));          $res = $this->db->query($sql);
637            $this->isDatabaseError($res);
638    
639            // Tant qu'il y a un résultat
640            while ($row = &$res->fetchRow(DB_FETCHMODE_ASSOC)) {
641                
642                // Le nom de la colonne est mise dans un tableau
643                $list_column[] = $row['column_name'];
644            }
645    
646            // Tableau des champs en erreur
647            $error_fields = array();
648    
649            // Pour chaque champ à tester
650            foreach ($list_fields as $value) {
651                
652                // S'il n'apparaît pas dans la liste des champs possible
653                if (!in_array($value, $list_column)) {
654    
655                    // Alors le champ est ajouté au tableau des erreurs
656                    $error_fields[] = $value;
657              }              }
         } else {  
             $this->displayMessage("error", _("Ce repertoire n'a pas de document."));  
658          }          }
659          return $file_list;  
660            // Si le tableau des erreurs n'est pas vide on le retourne
661            if (count($error_fields) > 0) {
662                return $error_fields;
663            }
664    
665            // Sinon on retourne le booléen true
666            return true;
667    
668      }      }
669    
670      /*      /*
671       * Store the data recived in the request into a file on the       *
      * local filesystem.  
      * @todo This function will need to be changed for the save to  
      * be on GED  
      * @param mixed $data The data received with the request  
      * @param string $id The consultation ID  
      * @return string OK on success, KO otherwise  
672       */       */
673                /**
674      function storeDecisionFile(&$fichier_base64, $basename, $dossier, $prefix = '') {       * Récupère la lettre type lié à un événement
675                 * @param  integer  $evenement L'identifiant de l'événement
676          if (empty($fichier_base64)) {       * @return integer             Retourne l'idenfiant de la lettre-type                             ou true
677              $this -> addToMessage("error", _("Le fichier est vide"));       */
678              return false;      function getLettreType($evenement){
679            
680             $lettretype = NULL;
681            
682             $sql =
683                "SELECT
684                    lettretype
685                FROM
686                    ".DB_PREFIXE."evenement
687                WHERE
688                    evenement = $evenement";
689                
690            $this->addToLog("getLettreType() : db->query(\"".$sql."\")", VERBOSE_MODE);
691            $res = $this->db->query($sql);
692            if ( database::isError($res)){
693                die();
694          }          }
         $dir = $this->getPathFolderTrs().$dossier;  
           
         // if a file already exists by that name and it  
         // is not a directory, back out  
         /*if (file_exists($dir) AND is_dir($dir)) {  
             $this -> addToMessage("error", _("Le repertoire n'existe pas, le fichier ne peut pas etre enregistre."));  
             return false;  
         }*/  
         // if a dirextory by that name exists, make sure it does  
         // not already contain an avis de consultation, MAYBE WE DON'T NEED THIS  
         if (file_exists($dir) AND is_dir($dir)) {  
             $dir_contents = trim(shell_exec('ls '.$dir));  
             if (strpos($dir_contents, ' ') != false) {  
                 $dir_contents = explode(' ', $dir_contents);  
             } else {  
                 $dir_contents = array($dir_contents);  
             }  
             foreach ($dir_contents as $basefname) { // very useful for consultation  
                 if (strpos($basefname, $prefix)!==false) {  
                     return _("Un retour d'avis existe deja.");  
                       
                 }  
             }  
         } else {  
             $this->createFolder($dossier);  
         }          
           
         // store the file contents into the file named:  
         //      consultation_<ID>_<file_name_received>  
         $file_len = strlen($fichier_base64);  
   
         $filename = $dir."/".$prefix.$basename;  
   
         $file = fopen($filename, 'w');  
         if (!$file) {  
             return _("Echec a la creation du fichier.");  
         }  
         // check that the number of bytes written is equal to the length  
         // of the data received  
         $num_written = fwrite($file, $fichier_base64, $file_len);  
695                    
696          if (!$num_written) {          if ( $res->numrows() > 0 ){
697              // remove the file                  
698              // the return value from shell can't be used for checking since              $row=& $res->fetchRow(DB_FETCHMODE_ASSOC);
699              // one can not know if the NULL returned is because there was no              $lettretype = $row['lettretype'];
             // output or because there was an error  
             $ret = shell_exec("rm -f $filename 2>&1");  
             //if ($ret == NULL) { // an error occured while deleting the file  
             //}  
             return _("La sauvegarde du fichier a echoue");  
700          }          }
701          fclose($file);        
702          return true;          return $lettretype;
703      }      }
704            
705      /**      /**
706       *       * Retourne le type de dossier d'autorisation du dossier courant :
707       */       * @param $idxDossier Le numéro du dossier d'instruction
708      function notExistsError ($explanation = NULL) {       * @return le code du type détaillée de dossier d'autorisation
709          // message       **/
710          $message_class = "error";      function getDATDCode($idxDossier) {
711          $message = _("Cette page n'existe pas.");          $sql = "SELECT dossier_autorisation_type_detaille.code
712          $this->addToMessage ($message_class, $message);                  FROM ".DB_PREFIXE."dossier_autorisation_type_detaille
713          //                  INNER JOIN ".DB_PREFIXE."dossier_autorisation
714          $this->setFlag(NULL);                      ON dossier_autorisation_type_detaille.dossier_autorisation_type_detaille =
715          $this->display();                         dossier_autorisation.dossier_autorisation_type_detaille
716                            INNER JOIN ".DB_PREFIXE."dossier ON dossier.dossier_autorisation = dossier_autorisation.dossier_autorisation
717          //                  WHERE dossier.dossier = '".$idxDossier."'";
718          die();          $res = $this->db->getOne($sql);
719            $this->addToLog("getDATDCode() : db->getOne(\"".$sql."\")", VERBOSE_MODE);
720            if ( database::isError($res)){
721                die();
722            }
723            return $res;
724      }      }
   
      // }}}  
   
725  }  }
726    
727  ?>  ?>
Legend:
Removed from v.943  
changed lines
  Added in v.2605
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26