/[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 638 by nhaye, Fri Nov 9 10:14:19 2012 UTC revision 3189 by vpihour, Fri Nov 28 16:46:53 2014 UTC
# Line 37  require_once PATH_OPENMAIRIE."om_applica Line 37  require_once PATH_OPENMAIRIE."om_applica
37   */   */
38  class utils extends application {  class utils extends application {
39    
40                // {{{
41        
42      /**      /**
43       * Desctructeur de la classe, cette methode (appelee automatiquement)       *
      * permet d'afficher le footer de la page, le footer HTML, et de  
      * deconnecter la base de donnees  
      *  
      * @return void  
44       */       */
45      function __destruct() {      function isAccredited($obj = NULL, $operator = "AND") {
46            // Lorsque l'utilisateur a le login 'admin' alors il est authorisé à
47          // Footer          // accéder à toutes les fonctions du logiciel
48          if (!defined('REST_REQUEST')) {          // XXX à modifier pour changer ça vers un profil et non un login utilisateur
49              $this->displayFooter();          if ($_SESSION["login"] == "admin") {
50                return true;
51          }          }
52            // Fonctionnement standard
53            return parent::isAccredited($obj, $operator);
54        }
55        
56        // }}}
57    
58        // {{{
59    
60          // Deconnexion SGBD      var $om_utilisateur = array();
61          $this->disconnectDatabase();      var $user_is_instr = NULL;
62        var $user_is_service = NULL;
63        var $user_is_admin = NULL;
64        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          // Logger      /**
71          $this->addToLog("__destruct()", EXTRA_VERBOSE_MODE);       * Méthode de récupération des informations de l'utilisateur connecté.
72         */
73        function getUserInfos() {
74            
75            // Si l'utilisateur est loggé $_SESSION existe
76            if(isset($_SESSION['login']) AND !empty($_SESSION['login'])) {
77                
78                // Récupération des infos utilisateur
79                $sqlUser = "SELECT om_utilisateur, nom, email, login, om_collectivite, om_profil ".
80                "FROM ".DB_PREFIXE."om_utilisateur WHERE login = '".$_SESSION['login']."'";
81                $resUser=$this->db->query($sqlUser);
82                $this->addToLog("getUserInfos(): db->query(\"".$sqlUser."\");", VERBOSE_MODE);
83                if ( database::isError($resUser)){
84                    die();
85                }
86                $this->om_utilisateur=&$resUser->fetchRow(DB_FETCHMODE_ASSOC);
87    
88          // Logger              // Récupère le profil et test si c'est un
89          $this->addToLog("__destruct() : ".$this->elapsedtime()." sec", VERBOSE_MODE);              $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          // Affichage des logs              // si c'est un administrateur technique
99          logger::instance()->displayLog();              // 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          // Footer HTML              //si c'est un service externe
108          if (!defined('REST_REQUEST')) {              if ($resProfil == "SERVICE CONSULTÉ") {
109              $this->displayHTMLFooter();                  $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
143                $sqlInstr = "SELECT instructeur.instructeur, instructeur.nom, instructeur.telephone,
144                division.division, division.code, division.libelle ".
145                "FROM ".DB_PREFIXE."instructeur INNER JOIN ".DB_PREFIXE."division ON division.division=instructeur.division ".
146                "WHERE instructeur.om_utilisateur = ".$this->om_utilisateur['om_utilisateur'];
147                $resInstr=$this->db->query($sqlInstr);
148                $this->addToLog("getUserInfos(): db->query(\"".$sqlInstr."\");", VERBOSE_MODE);
149                if ( database::isError($resInstr)){
150                    die();
151                }
152                $tempInstr=&$resInstr->fetchRow(DB_FETCHMODE_ASSOC);
153                // Si il y a un resultat c'est un instructeur
154                if(count($tempInstr)>0) {
155                    $this->user_is_instr=true;
156                    $this->om_utilisateur = array_merge($this->om_utilisateur,$tempInstr);
157                } else {
158                    $this->user_is_instr=false;
159                }
160                
161                // Récupération des infos de services consultés
162                $sqlServ = "SELECT service.service, service.abrege, service.libelle ".
163                "FROM ".DB_PREFIXE."service ".
164                "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'];
166                $resServ=$this->db->query($sqlServ);
167                $this->addToLog("getUserInfos(): db->query(\"".$sqlServ."\");", VERBOSE_MODE);
168                if ( database::isError($resServ)){
169                    die();
170                }
171                
172                while ($tempServ=&$resServ->fetchRow(DB_FETCHMODE_ASSOC)) {
173                    $this->om_utilisateur['service'][]=$tempServ;
174                }
175                // Si il y a un resultat c'est un utilisateur de service
176                if(isset($this->om_utilisateur['service'])) {
177                    $this->user_is_service=true;
178                } else {
179                    $this->user_is_service=false;
180                }
181            }
182        }
183    
184      /**      /**
185       * Cette méthode permet de vérifier si l'utilisateur est autorisé ou non à       * getter user_is_service
      * accéder à un élément et permet d'agir en conséquence  
      *  
      * @param  
      * @return mixed  
186       */       */
187      function isAuthorized($obj = NULL, $operator = "AND") {      function isUserService() {
   
188          //          //
189          if ($obj == NULL) {          if (is_null($this->user_is_service)) {
190              $obj = $this->right;              //
191                $this->getUserInfos();
192          }          }
193          //          //
194          if ($obj == NULL) {          return $this->user_is_service;
195              return true;      }
         }  
   
         // L'utilisateur n'est pas autorisé à accéder à l'élément  
         if (!$this->isAccredited($obj, $operator)) {  
196    
197        /**
198         * getter user_is_instr
199         */
200        function isUserInstructeur() {
201            //
202            if (is_null($this->user_is_instr)) {
203              //              //
204              $message_class = "error";              $this->getUserInfos();
205              $message = _("Droits insuffisants. Vous n'avez pas suffisament de ".          }
206                           "droits pour acceder a cette page.");          //
207              $this->addToMessage($message_class, $message);          return $this->user_is_instr;
208        }
209    
210        function isUserAdministrateur() {
211            //
212            if (is_null($this->user_is_admin)) {
213              //              //
214              $this->setFlag(NULL);              $this->getUserInfos();
             if (!defined('REST_REQUEST')) {  
                 $this->display();  
             }  
   
             // Arrêt du script  
             die();  
   
215          }          }
216            //
217            return $this->user_is_admin;
218        }
219    
220          // L'utilisateur est autorisé à accéder à l'élément      /**
221          return true;       * 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 setDatabaseConfig() {      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          // On recupere la liste des cles du tableau associatif de configuration      // Ajout de variables de session contenant la division pour permettre une
286          // de la connexion aux bases de donnees      // utilisation plus efficace dans les requetes
287          $database_keys = array_keys($this->database);      function triggerAfterLogin($utilisateur = NULL) {
288          // Si il y a plusieurs cles          //
289          if (count($database_keys) != 0) {          $sql = "SELECT instructeur.division, division.code
290              // On configure la premiere par defaut          FROM ".DB_PREFIXE."instructeur
291              $coll = $database_keys[0];          LEFT JOIN ".DB_PREFIXE."division
292          } else { // Si il n'y a aucune cle          ON instructeur.division = division.division
293              // Aucune base n'est configuree dans le fichier de configuration          WHERE instructeur.om_utilisateur='".$utilisateur["om_utilisateur"]."'";
294              // donc on affiche un message d'erreur          $res = $this->db->query($sql);
295              $class = "error";          $this->addToLog("triggerAfterLogin(): db->query(\"".$sql."\");", VERBOSE_MODE);
296              $message = _("Erreur de configuration. Contactez votre administrateur.");          if ( database::isError($res)){
             $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  
297              die();              die();
298          }          }
299            $row = $res->fetchrow(DB_FETCHMODE_ASSOC);
300          // Si la variable coll (representant la cle de la base sur laquelle          //
301          // nous travaillons) n'est pas en variable SESSION ou est en variable          if (isset($row["division"]) && $row["division"] != NULL) {
302          // SESSION mais n'existe pas dans les cles du tableau associatif de              $_SESSION["division"] = $row["division"];
303          // configuration de la connexion aux bases de donnees              $_SESSION["division_code"] = $row["code"];
         if (!isset($_SESSION['coll']) or  
             (isset($_SESSION['coll']) and  
              !isset($this->database[$_SESSION['coll']]))) {  
             // On configure la premiere par defaut  
             $_SESSION['coll'] = $coll;  
304          } else {          } else {
305              // On recupere la cle du tableau associatif de configuration de la              $_SESSION["division"] = "0";
306              // connexion aux bases de donnees correspondante a la base de              $_SESSION["division_code"] = "";
             // donnees sur laquelle nous travaillons  
             $coll = $_SESSION['coll'];  
307          }          }
308    
309          // On renvoi le tableau de parametres pour la connexion a la base      }    
310          $this->database_config = $this->database[$coll];  
311        // Affichage des actions supplémentaires
312        function displayActionExtras() {
313            // Affichage de la division si l'utilisateur en possède une
314            if ($_SESSION["division"] != 0) {
315                echo "\t\t\t<li class=\"action-division\">";
316                echo "(".$_SESSION['division_code'].")";
317                echo "</li>\n";
318            }
319      }      }
320    
321        // }}}
322    
323            
324          /**      function getDivisionFromDossier($dossier) {
325       * Cette méthode permet de se connecter à la base de données          //
326       * @return void          $sql = "select division from ".DB_PREFIXE."dossier ";
327       */          $sql .= " where dossier='".$dossier."'";
328      function connectDatabase() {          //
329          // On inclus la classe d'abstraction de base de donnees          $division = $this->db->getOne($sql);
330          require_once PATH_OPENMAIRIE."om_database.class.php";          $this->addToLog("getDivisionFromDossier(): db->getone(\"".$sql."\")", VERBOSE_MODE);
331          // On recupere le tableau de parametres pour la connexion a la base          database::isError($division);
332          $this->setDatabaseConfig();          //
333          // On fixe les options          return $division;
334          $options = array(      }
             'debug' => 2,  
             'portability' => DB_PORTABILITY_ALL,  
         );  
         // Instanciation de l'objet connexion a la base de donnees  
         $db = database::connect($this->database_config, $options);  
         // Logger  
         $this->addToLog("connectDatabase(): "._("Tentative de connexion au SGBD"), EXTRA_VERBOSE_MODE);  
         // Traitement particulier de l'erreur en cas d'erreur de connexion a la  
         // base de donnees  
         if (database::isError($db, true)) {  
             // Deconnexion de l'utilisateur  
             $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"];  
335    
336              // Definition des constantes pour l'acces aux informations de la base      // {{{ GESTION DES FICHIERS
337              // donnees facilement.      
338              $temp = "";      /**
339              if ($this->database_config["schema"] != "") {       *
340                  $temp = $this->database_config["schema"].".";       */
341        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            $this->setFlag(NULL);
348            $this->display();
349            
350            //
351            die();
352        }
353        
354         // }}}
355        /**
356         * 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         */
360        function getStatutDossier($idx){
361            
362            $statut = '';
363            
364            //Si l'identifiant du dossier d'instruction fourni est correct
365            if ( $idx != '' ){
366                
367                //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              }              }
             $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"]);  
381          }          }
382            return $statut;
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 isDatabaseError($dbobj = NULL, $return = false) {      function formatTimestamp ($date_str, $show = true) {
392    
393          //          // Sépare la date et l'heure
394          if (database::isError($dbobj, $return)) {          $date = explode(" ", $date_str);
395            if (count($date) != 2) {
396                return false;
397            }
398    
399              if ($return == true) {          // 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                  return true;          if (count ($date_db) != 3 and count ($date_show) != 3) {
406                return false;
407            }
408    
409            if (count ($date_db) == 3) {
410                // Vérifie que c'est une date valide
411                if (!checkdate($date_db[1], $date_db[2], $date_db[0])) {
412                    return false;
413              }              }
414                // Si c'est pour l'affichage de la date
415              //              if ($show == true) {
416              $class = "error";                  return $date_db [2]."/".$date_db [1]."/".$date_db [0]." ".$date[1];
417              $message = _("Erreur de base de donnees. Contactez votre administrateur.");              } else {
418              $this->addToMessage($class, $message);                  return $date[0];
   
             // Logger  
             $this->addToLog("isDatabaseError(): ".$dbobj->getDebugInfo(), DEBUG_MODE);  
             $this->addToLog("isDatabaseError(): ".$dbobj->getMessage(), DEBUG_MODE);  
   
             //  
             $this->setFlag(NULL);  
             if (!defined('REST_REQUEST')) {  
                 $this->display();  
                 //  
                 die();  
419              }              }
   
420          }          }
421    
422          //          //
423            if (count ($date_show) == 3) {
424                // Vérifie que c'est une date valide
425                if (!checkdate($date_show[1], $date_show[0], $date_show[2])) {
426                    return false;
427                }
428                // Si c'est pour l'affichage de la date
429                if ($show == true) {
430                    return $date[0];
431                } else {
432                    return $date_show [2]."-".$date_show [1]."-".$date_show [0]." ".$date[1];
433                }
434    
435            }
436          return false;          return false;
437    
438      }      }
       
439    
           
440      /**      /**
441       *       * Permet de calculer la liste des parcelles à partir de la chaîne passée en paramètre
442       * @return void       * et la retourner sous forme d'un tableau associatif
443         *
444         * @param  string $strParcelles chaîne de la parcelles
445         * @return array (array(quartier, section, parcelle), ...)
446       */       */
447      function displayMessage($class = "", $message = "") {      function parseParcelles($strParcelles) {
448          if (!defined('REST_REQUEST')) {          
449              $this->m->displayMessage($class, $message);          // Séparation des lignes
450            $references = explode(";", $strParcelles);
451            $liste_parcelles = array();
452            
453            // On boucle sur chaque ligne pour ajouter la liste des parcelles de chaque ligne
454            foreach ($references as $parcelles) {
455                
456                // On transforme la chaîne de la ligne de parcelles en tableau
457                $ref = str_split($parcelles);
458                // Les 1er caractères sont numériques
459                $num = true;
460                
461                // Tableau des champs de la ligne de références cadastrales
462                $reference_tab = array();
463                $temp = "";
464                foreach ($ref as $carac) {
465                    
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                }
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 addToLog($message, $type = DEBUG_MODE) {      function formatParcelleToSend($liste_parcelles) {
523    
524          //          //
525          if (!defined('REST_REQUEST')) {          $wParcelle = array();
526              logger::instance()->log("class ".get_class($this)." - ".$message, $type);  
527            //Formatage des références cadastrales pour l'envoi
528            foreach ($liste_parcelles as $value) {
529                    
530                // On ajoute les données dans le tableau que si quartier + section + parcelle
531                // a été fourni
532                if ($value["quartier"] !== ""
533                    && $value["section"] !== ""
534                    && $value["parcelle"] !== ""){
535                    
536                    //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                            str_pad($value["section"], 2, " ", STR_PAD_LEFT).
544                            $value["parcelle"];
545                    }
546                }
547          }          }
548    
549            //
550            return $wParcelle;
551      }      }
552        
553      /**      /**
554       * Envoie un mail avec piece jointe       * Récupère le code impôt par rapport au quartier
555       *       * @param  string $quartier Numéro de quartier
556       * @param string $title Titre du mail       * @return string           Code impôt
      * @param string $message Corps du mail  
      * @param string $recipient Destinataire du mail  
      * @param array $file Destinataire du mail  
      * @access public  
      * @return bool True si le mail est correctement envoye, false sinon.  
557       */       */
558      public function sendMail($title, $message, $recipient, $file = array()) {      function getCodeImpotByQuartier($quartier) {
           
         @include_once "../php/phpmailer/class.phpmailer.php";  
           
         if (!class_exists("PHPMailer")) {  
             $this->addToLog("sendMail(): !class_exists(\"PHPMailer\")", DEBUG_MODE);  
             return false;  
         }  
559    
560          //          $arrondissement = "";
561          $this->setMailConfig();  
562                    // Si le quartier fournis est correct
563          //          if ($quartier != "") {
564          if ($this->mail_config == false) {  
565              $this->addToLog("sendMail(): aucune configuration mail", DEBUG_MODE);              // Requête SQL
566              return false;              $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            (isset($this->config['path_scan']) ? "" : $this->config['path_scan'] = '../trs/numerisation/');
592                    
593          //          $default_sig_elyx = array(
594          $mail = new PHPMailer(true);              'wsdl' => '../tests/wsurbanisme.wsdl',
595                        'login' => 'sig',
596          //              'password' => 'sig',
597          $mail->IsSMTP();          );
598            (isset($this->config['sig_elyx']) ? "" : $this->config['sig_elyx'] = $default_sig_elyx);
599        }
600    
601          $mail->SMTPAuth = true; // enable SMTP authentication      /**
602          $mail->SMTPSecure = "tls";       * Retourne true si tous les paramètres du SIG externe ont bien été définis
603          $mail->Username = $this->mail_config["mail_username"];       * @return bool true/false
604          $mail->Password = $this->mail_config["mail_pass"];       */
605          if ($this->mail_config["mail_username"] == '') {      public function issetSIGParameter() {
606              $mail->SMTPAuth = false;          if($this->getParameter("sig_web_server") != NULL AND
607                $this->getParameter("sig_web_server") != "" AND
608                $this->getParameter("sig_couche_emprise_dossier") != NULL AND
609                $this->getParameter("sig_couche_emprise_dossier") != "" AND
610                $this->getParameter("sig_couche_affichage_dossier") != NULL AND
611                $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 {          } else {
616              $mail->SMTPAuth = true;              return false;
617          }          }
618          $mail->Port = $this->mail_config["mail_port"];      }
619          $mail->Host = $this->mail_config["mail_host"];  
620          $mail->AddReplyTo($this->mail_config["mail_from"], $this->mail_config["mail_from_name"]);      /**
621          $mail->From = $this->mail_config["mail_from"];       * Permet de vérifier que des champs existe dans une table
622          $mail->FromName = $this->mail_config["mail_from_name"];       * @param  array  $list_fields Liste des champs à tester
623          foreach (explode(",",$recipient) as $adresse) {       * @param  string $table       Table où les champs doivent exister
624              if (!$this->checkValidEmailAddress($adresse)) {       * @return mixed               Retourne les champs qui n'existent pas
625                  $this->addToLog("sendMail(): courriel incorrect ".$adresse, DEBUG_MODE);       *                             ou true
626                  return false;       */
627              } else      public function check_field_exist($list_fields, $table) {
628                  $mail->AddAddress(trim($adresse));  
629            // Instance de la classe en paramètre
630            require_once "../obj/".$table.".class.php";
631            $object = new $table("]", $this->db, DEBUG);
632    
633            // Récupère les champs de la table
634            foreach ($object->champs as $champ) {
635                $list_column[] = $champ;
636          }          }
637          $mail->IsHTML(true);  
638                    // Tableau des champs en erreur
639          // Corps du message          $error_fields = array();
640          $mail_body ="<html>";  
641          $mail_body .= "<head><title>".$title."</title></head>";          // Pour chaque champ à tester
642          $mail_body .= "<body>".$message."</body>";          foreach ($list_fields as $value) {
         $mail_body .= "</html>";  
           
         $mail->Subject  = $title;  
         $mail->MsgHTML($mail_body);  
         foreach($file as $oneFile) {  
643                            
644              if($oneFile['stream']){              // S'il n'apparaît pas dans la liste des champs possible
645                  $mail->AddStringAttachment($oneFile['content'], $oneFile['title'], $oneFile['encoding'] = 'base64',$oneFile['type'] = 'application/octet-stream');              if (!in_array($value, $list_column)) {
646              } else{  
647                  $mail->AddAttachment($oneFile['url']);                  // Alors le champ est ajouté au tableau des erreurs
648                    $error_fields[] = $value;
649              }              }
650          }          }
651          // Envoie de l'email  
652          if ($mail->Send()) {          // Si le tableau des erreurs n'est pas vide on le retourne
653              return true;          if (count($error_fields) > 0) {
654          } else {              return $error_fields;
             $this->addToLog("sendMail(): ".$mail->ErrorInfo, DEBUG_MODE);  
             return false;  
655          }          }
656    
657            // Sinon on retourne le booléen true
658            return true;
659    
660      }      }
661    
662      /**      /*
663       *       *
664       */       */
665      function isAccredited($obj = NULL, $operator = "AND") {      /**
666          // Lorsque l'utilisateur a le login 'admin' alors il est authorisé à       * Récupère la lettre type lié à un événement
667          // accéder à toutes les fonctions du logiciel       * @param  integer  $evenement L'identifiant de l'événement
668          // XXX à modifier pour changer ça vers un profil et non un login utilisateur       * @return integer             Retourne l'idenfiant de la lettre-type                             ou true
669          if ($_SESSION["login"] == "admin") {       */
670              return true;      function getLettreType($evenement){
671            
672             $lettretype = NULL;
673            
674             $sql =
675                "SELECT
676                    lettretype
677                FROM
678                    ".DB_PREFIXE."evenement
679                WHERE
680                    evenement = $evenement";
681                
682            $this->addToLog("getLettreType() : db->query(\"".$sql."\")", VERBOSE_MODE);
683            $res = $this->db->query($sql);
684            if ( database::isError($res)){
685                die();
686          }          }
687          // Fonctionnement standard          
688          return parent::isAccredited($obj, $operator);          if ( $res->numrows() > 0 ){
689                    
690                $row=& $res->fetchRow(DB_FETCHMODE_ASSOC);
691                $lettretype = $row['lettretype'];
692            }
693          
694            return $lettretype;
695      }      }
696            
697      /*      /**
698       * Methode permettant de lister tous les fichiers d'un dossier       * Retourne le type de dossier d'autorisation du dossier courant :
699         * @param $idxDossier Le numéro du dossier d'instruction
700         * @return le code du type détaillée de dossier d'autorisation
701         **/
702        function getDATDCode($idxDossier) {
703            $sql = "SELECT dossier_autorisation_type_detaille.code
704                    FROM ".DB_PREFIXE."dossier_autorisation_type_detaille
705                    INNER JOIN ".DB_PREFIXE."dossier_autorisation
706                        ON dossier_autorisation_type_detaille.dossier_autorisation_type_detaille =
707                           dossier_autorisation.dossier_autorisation_type_detaille
708                    INNER JOIN ".DB_PREFIXE."dossier ON dossier.dossier_autorisation = dossier_autorisation.dossier_autorisation
709                    WHERE dossier.dossier = '".$idxDossier."'";
710            $res = $this->db->getOne($sql);
711            $this->addToLog("getDATDCode() : db->getOne(\"".$sql."\")", VERBOSE_MODE);
712            if ( database::isError($res)){
713                die();
714            }
715            return $res;
716        }
717    
718        /**
719         * Permet de copier un enregistrement
720         * @param  mixed $idx   Identifiant de l'enregistrment
721         * @param  string $obj   Objet de l'enregistrment
722         * @param  string $objsf Objets associés
723         * @return array        Tableau des nouveaux id et du message
724       */       */
725      function get_folder_file_list($id_folder) {      function copier($idx, $obj, $objsf) {
726    
727          $file_list = array();          // Tableau de résultat
728          if(is_dir('../trs/'.$id_folder)) {          $resArray = array();
729              if($dossier = opendir('../trs/'.$id_folder)) {          // Message retourné à l'utilisateur
730                            $message = "";
731                  while(false !== ($fichier = readdir($dossier))) {          // Type du message (valid ou error)
732                            $message_type = "valid";
733                      if($fichier != '.' && $fichier != '..' && !is_dir($fichier)) {  
734                                // Requête SQL permettant de récupérer les informations sur l'objet métier
735                          $file_list[]=$fichier;          $sql = "SELECT *
736                      } // On ferme le if (qui permet de ne pas afficher index.php, etc.)                  FROM ".DB_PREFIXE.$obj."
737                                    WHERE ".$obj." = ".$idx;
738                  } // On termine la boucle          $res = $this->db->query($sql);
739                    $this->isDatabaseError($res);
740                  closedir($dossier);  
741                // Valeurs clonées
742              } else {          $valF = array();
743                  $this->displayMessage("error", _("Les documents du dossier ne sont pas accessible."));          while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
744                // Recupère la valeur
745                $valF = $row;
746            }
747    
748            // Valeurs non clonées
749            // Identifiant modifié pour que ça soit un ajout
750            $valF[$obj] = "]";
751    
752            // Inclus la classe de l'objet métier
753            require_once "../obj/".$obj.".class.php";
754    
755            // Instance de l'objet métier
756            $clone_obj = new $obj("]", $this->db, DEBUG);
757            // Si dans l'objet métier la fonction "copier" existe
758            if (method_exists($clone_obj, "copier")) {
759                // Traitement sur les valeurs du duplicata
760                $valF = $clone_obj->copier($valF, $objsf, DEBUG);
761                // Recupère les messages retourné par la fonction
762                $message .= $valF['message'];
763                // Supprime les messages de la liste des valeurs
764                unset($valF['message']);
765            }
766            // Ajoute le duplicata
767            $clone_obj->ajouter($valF, $this->db, DEBUG);
768            // Si aucune erreur se produit dans la classe instanciée
769            if ($clone_obj->correct === true) {
770                // Récupère l'identifiant de l'objet créé
771                $clone_obj_id = $clone_obj->valF[$obj];
772    
773                // Message
774                $message .= sprintf(_("La copie de l'enregistrement %s avec l'identifiant %s s'est effectuee avec succes"), "<span class='bold'>"._($obj)."</span>", "<span class='bold'>".$idx."</span>")."<br />";
775    
776                // Ajout de l'identifant au tableau des résultat
777                $resArray[$obj.'_'.$idx] = $clone_obj_id;
778    
779                // S'il y a au moins un objet metier associé
780                if ($objsf != "") {
781                    // Liste des objet métier associés
782                    $list_objsf = explode(",", $objsf);
783                    // Pour chaque objet associé
784                    foreach ($list_objsf as $key => $objsf) {
785                        // Inclus la classe de l'objet métier associé
786                        require_once "../obj/".$objsf.".class.php";
787    
788                        // Requête SQL permettant de récupérer les informations sur
789                        // l'objet métier associé
790                        $sql = "SELECT *
791                                FROM ".DB_PREFIXE.$objsf."
792                                WHERE ".$obj." = ".$idx;
793                        $res = $this->db->query($sql);
794                        $this->isDatabaseError($res);                    
795    
796                        // Pour chaque élément associé
797                        while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
798                            // Identifiant de l'objet associé à copier
799                            $idxsf = $row[$objsf];
800    
801                            // Valeurs clonées
802                            $valF = $row;
803                            // Valeurs non clonées
804                            $valF[$obj] = $clone_obj_id;
805                            // Identifiant modifié pour que ça soit un ajout
806                            $valF[$objsf] = "]";
807                            // Instance de l'objet métier associé
808                            $clone_objsf = new $objsf("]", $this->db, DEBUG);
809                            // Si dans l'objet métier associé
810                            // la fonction "copier" existe
811                            if (method_exists($clone_objsf, "copier")) {
812                                // Traitement sur les valeurs du duplicata
813                                $valF = $clone_objsf->copier($valF, $objsf, DEBUG);
814                                // Recupère les messages retourné par la fonction
815                                $message .= $valF['message'];
816                                // Supprime les messages de la liste des valeurs
817                                unset($valF['message']);
818                            }
819                            // Ajoute le duplicata
820                            $clone_objsf->ajouter($valF, $this->db, DEBUG);
821                            // Si aucune erreur se produit dans la classe instanciée
822                            if ($clone_objsf->correct === true) {
823                                // Récupère l'identifiant de l'objet créé
824                                $clone_objsf_id = $clone_objsf->valF[$objsf];
825    
826                                // Message
827                                $message .= sprintf(_("La copie de l'enregistrement %s avec l'identifiant %s s'est effectuee avec succes"), "<span class='bold'>"._($objsf)."</span>", "<span class='bold'>".$idxsf."</span>")."<br />";
828    
829                                // Ajout de l'identifant au tableau des résultat
830                                $resArray[$objsf.'_'.$row[$objsf]] = $clone_objsf_id;
831                            } else {
832    
833                                // Message d'erreur récupéré depuis la classe
834                                $message .= $clone_objsf->msg;
835                                // Type du message
836                                $message_type = "error";
837                            }
838                        }
839                    }
840              }              }
841            //    
842          } else {          } else {
843              $this->displayMessage("error", _("Ce dossier n'a pas de document."));  
844                // Message d'erreur récupéré depuis la classe
845                $message .= $clone_obj->msg;
846                // Type du message
847                $message_type = "error";
848          }          }
849          return $file_list;  
850            // Ajout du message au tableau des résultats
851            $resArray['message'] = $message;
852            // Ajout du type de message au tableau des résultats
853            $resArray['message_type'] = $message_type;
854    
855            // Retourne le tableau des résultats
856            return $resArray;
857      }      }
858    
859      /*      /**
860       * Store the data recived in the request into a file on the       * Permet de détailler les conditions pour l'affichage des contraintes dans
861       * local filesystem.       * une édition.
862       * @todo This function will need to be changed for the save to       * @param string $contraintes_param    Chaine des conditions
863       * be on GED       *
864       * @param mixed $data The data received with the request       * @return array                        Conditions
      * @param string $id The consultation ID  
      * @return string OK on success, KO otherwise  
865       */       */
866        function explodeConditionContrainte($contraintes_param) {
867    
868            // Initialisation des variables
869            $return = array();
870            $listGroupes = "";
871            $listSousgroupes = "";
872            $service_consulte = "";
873    
874            // Coupe la condition au ";"
875            // Doit séparer groupe et sous-groupe
876            $contraintes_params = explode(";", $contraintes_param);
877                    
878      function storeDecisionFile(&$fichier_base64, $basename, $dossier, $prefix = '') {          // Pour chaque paramètres
879                    foreach ($contraintes_params as $value) {
880          if (empty($fichier_base64)) {              // Si le mot-clés "liste_groupe="
881              $this -> addToMessage("error", _("Le fichier est vide"));              if (strstr($value, "liste_groupe=")) {
882              return false;                  // On enlève le mots-clés "liste_groupe="
883                    $listGroupes = str_replace("liste_groupe=", "", $value);
884                }
885                // Si le mot-clés "liste_ssgroupe="
886                if (strstr($value, "liste_ssgroupe=")) {
887                    // On enlève le mots-clés "liste_ssgroupe="
888                    $listSousgroupes = str_replace("liste_ssgroupe=", "", $value);
889                }
890                // Si le mot-clés "service_consulte="
891                if (strstr($value, "service_consulte=")) {
892                    // On enlève le mots-clés "service_consulte="
893                    $service_consulte = str_replace("service_consulte=", "", $value);
894                }
895          }          }
896          $dir = $this->getPathFolderTrs().$dossier;  
897                    // Récupère la liste des groupes et sous-groupes qui doivent
898          // if a file already exists by that name and it          // être utilisés pour la condition
899          // is not a directory, back out          if ($listGroupes != "") {
900          /*if (file_exists($dir) AND is_dir($dir)) {              $listGroupes = explode(",", $listGroupes);
901              $this -> addToMessage("error", _("Le repertoire n'existe pas, le fichier ne peut pas etre enregistre."));          }
902              return false;          if ($listSousgroupes != "") {
903          }*/              $listSousgroupes = explode(",", $listSousgroupes);
904          // if a dirextory by that name exists, make sure it does          }
905          // not already contain an avis de consultation, MAYBE WE DON'T NEED THIS  
906          if (file_exists($dir) AND is_dir($dir)) {          // Tableau à retourner
907              $dir_contents = trim(shell_exec('ls '.$dir));          $return['groupes'] = $listGroupes;
908              if (strpos($dir_contents, ' ') != false) {          $return['sousgroupes'] = $listSousgroupes;
909                  $dir_contents = explode(' ', $dir_contents);          $return['service_consulte'] = $service_consulte;
910              } else {  
911                  $dir_contents = array($dir_contents);          //
912            return $return;
913        }
914    
915        /**
916         * Traitement pour créer la condition sur les contraintes dans les éditions.
917         * @param string $part SQL et parti du pdf (sql, titre ou corps)
918         *
919         * @return string      Condition pour la requête sur les contraintes
920         */
921        function traitement_condition_contrainte($part) {
922    
923            // Initialisationd de la condition
924            $whereContraintes = "";
925    
926            // Détaille la condtion
927            $explodeConditionContrainte = $this->explodeConditionContrainte($part);
928    
929            // Récupère les groupes, sous-groupes et service_consulte pour la condition
930            $groupes = $explodeConditionContrainte['groupes'];
931            $sousgroupes = $explodeConditionContrainte['sousgroupes'];
932            $service_consulte = $explodeConditionContrainte['service_consulte'];
933    
934            // Pour chaque groupe
935            if ($groupes != "") {
936                foreach ($groupes as $key => $groupe) {
937                    // Si le groupe n'est pas vide
938                    if (!empty($groupe)) {
939                        // Choisit l'opérateur logique
940                        $op_logique = $key > 0 ? 'OR' : 'AND (';
941                        // Ajoute la condition
942                        $whereContraintes .= " ".$op_logique." lower(trim(both E'\n\r\t' from contrainte.groupe)) = lower('"
943                            .pg_escape_string($groupe)."')";
944                    }
945              }              }
946              foreach ($dir_contents as $basefname) { // very useful for consultation              // S'il y a des valeurs dans groupe
947                  if (strpos($basefname, $prefix)!==false) {              if (count($groupe) > 0) {
948                      return _("Un retour d'avis existe deja.");                  // Ferme la parenthèse
949                                        $whereContraintes .= " ) ";
950                }
951            }
952    
953            // Pour chaque sous-groupe
954            if ($sousgroupes != "") {
955                foreach ($sousgroupes as $key => $sousgroupe) {
956                    // Si le sous-groupe n'est pas vide
957                    if (!empty($sousgroupe)) {
958                        // Choisit l'opérateur logique
959                        $op_logique = $key > 0 ? 'OR' : 'AND (';
960                        // Ajoute la condition
961                        $whereContraintes .= " ".$op_logique." lower(trim(both E'\n\r\t' from contrainte.sousgroupe)) = lower('"
962                            .pg_escape_string($sousgroupe)."')";
963                  }                  }
964              }              }
965                // S'il y a des valeurs dans sous-groupe
966                if (count($sousgroupes) > 0) {
967                    // Ferme la parenthèse
968                    $whereContraintes .= " ) ";
969                }
970          }          }
971          // if no file by that name exists, create the directory  
972                    // Si l'option service_consulte n'est pas vide
973          if (!file_exists($dir)) {          if ($service_consulte != "") {
974              if (!mkdir($dir, 0775)) {              // Ajoute la condition
975                  return _("Erreur dans la création de répertoire.");              $whereContraintes .= " AND service_consulte = cast(lower('".$service_consulte."') as boolean) ";
976            }
977    
978            // Condition retournée
979            return $whereContraintes;
980        }
981    
982        /**
983         * Calcule une date par l'ajout ou la soustraction de mois
984         * @param date    $date     Date de base
985         * @param integer $delay    Délais à ajouter (en mois)
986         * @param string  $operator Opérateur pour le calcul ("-" ou "+")
987         *
988         * @return date             Date calculée
989         */
990        function mois_date($date, $delay, $operator = "+") {
991                
992            // Si aucune date n'a été fournie ou si ce n'est pas une date correctement formatée
993            if ( is_null($date) || $date == "" ||
994                preg_match('/[0-9]{4}-[0-9]{2}-[0-9]{2}/', $date) == 0 ){
995                return null;
996            }
997    
998            // Découpage de la date
999            $temp = explode("-", $date);
1000            $day = (int) $temp[2];
1001            $month = (int) $temp[1];
1002            $year = (int) $temp[0];
1003    
1004            // Si c'est une addition
1005            if ($operator == '+') {
1006                // Année à ajouter
1007                $year += floor($delay / 12);
1008                // Mois restant
1009                $nb_month = ($delay % 12);
1010                // S'il y a des mois restant
1011                if ($nb_month != 0) {
1012                    // Ajout des mois restant
1013                    $month += $nb_month;
1014                    // Si ça dépasse le mois 12 (décembre)
1015                    if ($month > 12) {
1016                        // Soustrait 12 au mois
1017                        $month -= 12;
1018                        // Ajoute 1 à l'année
1019                        $year += 1;
1020                    }
1021              }              }
1022          }          }
1023            
1024                    // Si c'est une soustraction
1025          // store the file contents into the file named:          if ($operator == "-") {
1026          //      consultation_<ID>_<file_name_received>              // Année à soustraire
1027          $file_len = strlen($fichier_base64);              $year -= floor($delay / 12);
1028                // Mois restant
1029          $filename = $dir."/".$prefix.$basename;              $nb_month = ($delay % 12);
1030                // S'il y a des mois restant
1031          $file = fopen($filename, 'w');              if ($nb_month != 0) {
1032          if (!$file) {                  // Soustrait le délais
1033              return _("Echec a la creation du fichier.");                  $month -= $nb_month;
1034          }                  // Si ça dépasse le mois 1 (janvier)
1035          // check that the number of bytes written is equal to the length                  if ($month < 1) {
1036          // of the data received                      // Soustrait 12 au mois
1037          $num_written = fwrite($file, $fichier_base64, $file_len);                      $month += 12;
1038                                // Ajoute 1 à l'année
1039          if (!$num_written) {                      $year -= 1;
1040              // remove the file                  }
1041              // the return value from shell can't be used for checking since              }
1042              // one can not know if the NULL returned is because there was no          }
1043              // output or because there was an error  
1044              $ret = shell_exec("rm -f $filename 2>&1");          // Calcul du nombre de jours dans le mois sélectionné
1045              //if ($ret == NULL) { // an error occured while deleting the file          switch($month) {
1046              //}              // Mois de février
1047              return _("La sauvegarde du fichier a echoue");              case "2":
1048                    if ($year % 4 == 0 && $year % 100 != 0 || $year % 400 == 0) {
1049                        $day_max = 29;
1050                    } else {
1051                        $day_max = 28;
1052                    }
1053                break;
1054                // Mois d'avril, juin, septembre et novembre
1055                case "4":
1056                case "6":
1057                case "9":
1058                case "11":
1059                    $day_max = 30;
1060                break;
1061                // Mois de janvier, mars, mai, juillet, août, octobre et décembre
1062                default:
1063                    $day_max = 31;
1064            }
1065    
1066            // Si le jour est supérieur au jour maximum du mois
1067            if ($day > $day_max) {
1068                // Le jour devient le jour maximum
1069                $day = $day_max;
1070            }
1071    
1072            // Compléte le mois et le jour par un 0 à gauche si c'est un chiffre
1073            $month = str_pad($month, 2, "0", STR_PAD_LEFT);
1074            $day = str_pad($day, 2, "0", STR_PAD_LEFT);
1075    
1076            // Retourne la date calculée
1077            return $year."-".$month."-".$day ;
1078        }
1079    
1080        /**
1081         * Vérifie la valididité d'une date.
1082         * @param string $pDate  Date à vérifier
1083         *
1084         * @return boolean
1085         */
1086        function check_date($pDate) {
1087    
1088            // Vérifie si c'est une date valide
1089            if (preg_match("/^([0-9]{4})-([0-9]{2})-([0-9]{2})$/", $pDate, $date)
1090                && checkdate($date[2], $date[3], $date[1])
1091                && $date[1] >= 1900) {
1092                //
1093                return true;
1094          }          }
1095          fclose($file);  
1096          return true;          //
1097            return false;
1098      }      }
1099    
1100  }  }
1101    
1102  ?>  ?>

Legend:
Removed from v.638  
changed lines
  Added in v.3189

[email protected]
ViewVC Help
Powered by ViewVC 1.1.26