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

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

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

revision 1571 by nhaye, Thu Mar 28 12:22:00 2013 UTC revision 2771 by softime, Tue Feb 25 14:56:56 2014 UTC
# Line 12  Line 12 
12   *     var $idxformulaire;   *     var $idxformulaire;
13   * - modification des données dans dossier trigger avant   * - modification des données dans dossier trigger avant
14   * [modify dossier data with trigger function]   * [modify dossier data with trigger function]
15   * - function moisdate : pour ajouter des mois a une date   * - function mois_date : pour ajouter des mois a une date
16   *   [add months (delay) and calculation final date]   *   [add months (delay) and calculation final date]
17   * - voir script_lang.js : bible ...   * - voir script_lang.js : bible ...
18   *   *
# Line 32  class instruction extends instruction_ge Line 32  class instruction extends instruction_ge
32      var $archive_date_depot; // specific      var $archive_date_depot; // specific
33      var $retourformulaire;   // specific      var $retourformulaire;   // specific
34      var $idxformulaire;      // specific      var $idxformulaire;      // specific
35        var $valEvenement;
36        // Tableau contenant une partie des métadonnées arrêtés
37        var $metadonneesArrete;
38    
39        var $metadata = array(
40            "om_fichier_instruction" => array(
41                "dossier" => "getDossier",
42                "dossier_version" => "getDossierVersion",
43                "numDemandeAutor" => "getNumDemandeAutor",
44                "anneemoisDemandeAutor" => "getAnneemoisDemandeAutor",
45                "typeInstruction" => "getTypeInstruction",
46                "statutAutorisation" => "getStatutAutorisation",
47                "typeAutorisation" => "getTypeAutorisation",
48                "dateEvenementDocument" => "getDateEvenementDocument",
49                "groupeInstruction" => 'getGroupeInstruction',
50                "title" => 'getTitle',
51            ),
52        );
53    
54      function instruction($id, &$db, $debug) {  
55        function __construct($id, &$db, $debug) {
56          $this->constructeur($id, $db, $debug);          $this->constructeur($id, $db, $debug);
57      }      }
58    
# Line 51  class instruction extends instruction_ge Line 70  class instruction extends instruction_ge
70              && isset($this->f->om_utilisateur["division"])              && isset($this->f->om_utilisateur["division"])
71              && $this->f->om_utilisateur["division"] != $this->getDivisionFromDossier()) {              && $this->f->om_utilisateur["division"] != $this->getDivisionFromDossier()) {
72              //              //
73              $this->actions_sup = array();              //On cache les liens d'action
74              $this->setParameter("actions", array());              $this->parameters["actions"]["modifier"] = NULL;
75                $this->parameters["actions"]["supprimer"] = NULL;
76                $this->actions_sup["finalisation"] = NULL;
77          }          }
78          // Si une action 'lu' est présente et que le champ lu est à true          // Si une action 'lu' est présente et que le champ lu est à true
79          // on supprime l'action          // on supprime l'action
# Line 61  class instruction extends instruction_ge Line 82  class instruction extends instruction_ge
82              && $this->val[array_search("lu", $this->champs)]== "t") {              && $this->val[array_search("lu", $this->champs)]== "t") {
83              unset($this->actions_sup["lu"]);              unset($this->actions_sup["lu"]);
84          }          }
85                
86            //Si le document est déjà finalisé, on affiche uniquement le lien de
87            //dé-finalisation
88            $om_final_instruction = $this->getVal("om_final_instruction");
89            if ( isset($this->actions_sup["finalisation"]) &&
90                $om_final_instruction== "t" ){
91                    
92                //On cache les liens d'action
93                $this->parameters["actions"]["modifier"] = NULL;
94                $this->parameters["actions"]["supprimer"] = NULL;
95                //On cache le lien de finalisation et on affiche le bon lien pour l'édition
96                $this->actions_sup["finalisation"] = NULL;
97                $this->actions_sup["pdfetat"]["lien"] = "../spg/file.php?id=";
98                $this->actions_sup["pdfetat"]["id"] =
99                    "&obj=instruction&champ=om_fichier_instruction";
100            }
101            //Si le document n'est pas finalisé, on affiche uniquement le lien de
102            //finalisation
103            if ( isset($this->actions_sup["definalisation"]) &&
104                $om_final_instruction!= "t" ){
105                    
106                //On cache le lien de finalisation et on affiche le bon lien pour l'édition
107                $this->actions_sup["definalisation"] = NULL;
108                $this->actions_sup["pdfetat"]["lien"] = "../app/pdf_instruction.php?idx=";
109                $this->actions_sup["pdfetat"]["id"] = "";
110            }
111            
112            $idxformulaire = $this->getParameter("idxformulaire");
113            $retourformulaire = $this->getParameter("retourformulaire");
114            //Si le dossier d'instruction auquel est rattachée l'instruction est cloturé,
115            //on affiche pas les liens du portlet
116            if ( $idxformulaire != '' &&
117                (
118                    $retourformulaire == 'dossier' ||
119                    $retourformulaire == 'dossier_instruction' ||
120                    $retourformulaire == 'dossier_instruction_mes_encours' ||
121                    $retourformulaire == 'dossier_instruction_tous_encours' ||
122                    $retourformulaire == 'dossier_instruction_mes_clotures' ||
123                    $retourformulaire == 'dossier_instruction_tous_clotures'
124                )){
125    
126                //On récuppère le statut du dossier d'instruction        
127                $statut = $this->getStatutAutorisationDossier($idxformulaire);
128                // Si l'utilisateur est un instructeur, que le statut est clôturé
129                // et que l'événement n'est pas identifié comme non verrouillable
130                if ( $this->f->isUserInstructeur() && $statut == "cloture"
131                    && $this->checkEvenementNonVerrouillable($this->getVal("instruction")) === false){
132                    
133                    //On cache les liens du portlet
134                    $this->parameters["actions"]["modifier"] = NULL;
135                    $this->actions_sup["finalisation"] = NULL;
136                    $this->actions_sup["definalisation"] = NULL;
137                }
138            }
139      }      }
140    
141      /**      /**
# Line 74  class instruction extends instruction_ge Line 149  class instruction extends instruction_ge
149              && $this->f->om_utilisateur["division"] != $this->getDivisionFromDossier()              && $this->f->om_utilisateur["division"] != $this->getDivisionFromDossier()
150              && $this->getParameter("maj") != 3) {              && $this->getParameter("maj") != 3) {
151              //              //
152                $this->addToLog("canAccess(): utilisateur instructeur sur un dossier d'une autre division", EXTRA_VERBOSE_MODE);
153                return false;
154            }
155    
156            $retourformulaire = $this->getParameter("retourformulaire");
157            // Si l'utilisateur est un instructeur, que le dossier est cloturé,
158            // que l'utilisateur est dans un sous formulaire précis, que le
159            // formulaire n'est pas en mode consulter ou ajouter et que l'événement
160            // n'est pas identifié comme non verrouillable
161            if ( $this->f->isUserInstructeur() &&
162                $this->getStatutAutorisationDossier($this->getParameter("idxformulaire")) == "cloture"
163                && (
164                    $retourformulaire == 'dossier' ||
165                    $retourformulaire == 'dossier_instruction' ||
166                    $retourformulaire == 'dossier_instruction_mes_encours' ||
167                    $retourformulaire == 'dossier_instruction_tous_encours' ||
168                    $retourformulaire == 'dossier_instruction_mes_clotures' ||
169                    $retourformulaire == 'dossier_instruction_tous_clotures'
170                )
171                && $this->getParameter("maj") != 3
172                && $this->getParameter("maj") != 0
173                && $this->checkEvenementNonVerrouillable($this->getVal("instruction")) === false) {
174    
175              return false;              return false;
176          }          }
177          //          //
# Line 81  class instruction extends instruction_ge Line 179  class instruction extends instruction_ge
179      }      }
180    
181      /**      /**
182       * Cette méthode permet de récupérer la division d'un dossier       * Cette variable permet de stocker le résultat de la méthode
183         * getDivisionFromDossier() afin de ne pas effectuer le recalcul à chacun de
184         * ces appels.
185         * @var string Code de la division du dossier en cours
186         */
187        var $_division_from_dossier = NULL;
188    
189        /**
190         * Cette méthode permet de récupérer le code de division correspondant
191         * au dossier sur lequel on se trouve.
192         *
193         * @return string Code de la division du dossier en cours
194       */       */
195      function getDivisionFromDossier() {      function getDivisionFromDossier() {
196    
197            // Cette méthode peut être appelée plusieurs fois lors d'une requête.
198            // Pour éviter de refaire le traitement de recherche de la division
199            // alors on vérifie si nous ne l'avons pas déjà calculé.
200            if ($this->_division_from_dossier != NULL) {
201                // Logger
202                $this->addToLog("getDivisionFromDossier(): retour de la valeur déjà calculée - '".$this->_division_from_dossier."'", EXTRA_VERBOSE_MODE);
203                // On retourne la valeur déjà calculée
204                return $this->_division_from_dossier;
205            }
206    
207            // Par défaut, on définit la valeur du dossier à NULL
208            $dossier = NULL;
209            // Test sur le mode et le contexte du formulaire
210            if ($this->getParameter("maj") == 0
211                && ($this->getParameter("retourformulaire") == "dossier"
212                    || $this->getParameter("retourformulaire") == "dossier_instruction"
213                    || $this->getParameter("retourformulaire") == "dossier_instruction_mes_encours"
214                    || $this->getParameter("retourformulaire") == "dossier_instruction_tous_encours"
215                    || $this->getParameter("retourformulaire") == "dossier_instruction_mes_clotures"
216                    || $this->getParameter("retourformulaire") == "dossier_instruction_tous_clotures")) {
217                // Si on se trouve en mode AJOUT (seul mode où l'enregistrement
218                // n'existe pas en base de données) ET que nous nous trouvons
219                // dans le contexte d'un dossier d'instruction alors on récupère
220                // le numéro de dossier depuis le paramètre 'idxformulaire'
221                $dossier = $this->getParameter("idxformulaire");
222            } else {
223                // Sinon on récupère le numéro de dossier dans le champs dossier de
224                // l'enregistrement (en base de données)
225                $dossier = $this->getVal("dossier");
226            }
227    
228            // On appelle la méthode de la classe utils qui renvoi le code de la
229            // division d'un dossier, on la stocke pour ne pas refaire le calcul au
230            // prochain appel de cette méthode
231            $this->_division_from_dossier = $this->f->getDivisionFromDossier($dossier);
232            // Logger
233            $this->addToLog("getDivisionFromDossier(): retour de la valeur nouvellement calculée - '".$this->_division_from_dossier."'", EXTRA_VERBOSE_MODE);
234            // On retourne la valeur retournée
235            return $this->_division_from_dossier;
236    
237        }
238    
239        /**
240         * Cette méthode permet de récupérer le dossier d'autorisation d'un dossier
241         */
242        function getNumDemandeAutorFromDossier($id) {
243          //          //
244          if (!isset($this->val[array_search("dossier", $this->champs)])) {          if (!isset($id)) {
245              return NULL;              return NULL;
246          }          }
247          //          //
248          $sql = "select division from ".DB_PREFIXE."dossier ";          $sql = "select dossier_autorisation from ".DB_PREFIXE."dossier ";
249          $sql .= " where dossier='".$this->val[array_search("dossier", $this->champs)]."'";          $sql .= " where dossier='".$id."'";
250          //          //
251          $division = $this->db->getOne($sql);          $dossier_autorisation = $this->db->getOne($sql);
252          $this->addToLog("getDivisionFromDossier(): db->getone(\"".$sql."\")", VERBOSE_MODE);          $this->addToLog("getNumDemandeAutorFromDossier(): db->getone(\"".$sql."\")", VERBOSE_MODE);
253          database::isError($division);          database::isError($dossier_autorisation);
254          //          //
255          return $division;          return $dossier_autorisation;
256      }      }
257    
258      // }}}      // }}}
# Line 106  class instruction extends instruction_ge Line 262  class instruction extends instruction_ge
262          parent::setType($form, $maj);          parent::setType($form, $maj);
263          // On cache tous les champs          // On cache tous les champs
264          // XXX          // XXX
265          $form->setType('complement3', 'hidden');          $form->setType('complement3_om_html', 'hidden');
266          $form->setType('bible3', 'hidden');          $form->setType('bible3', 'hidden');
267          $form->setType('complement4', 'hidden');          $form->setType('complement4_om_html', 'hidden');
268          $form->setType('bible4', 'hidden');          $form->setType('bible4', 'hidden');
269          $form->setType('complement5', 'hidden');          $form->setType('complement5_om_html', 'hidden');
270          $form->setType('bible5', 'hidden');          $form->setType('bible5', 'hidden');
271          $form->setType('complement6', 'hidden');          $form->setType('complement6_om_html', 'hidden');
272          $form->setType('bible6', 'hidden');          $form->setType('bible6', 'hidden');
273          $form->setType('complement7', 'hidden');          $form->setType('complement7_om_html', 'hidden');
274          $form->setType('bible7', 'hidden');          $form->setType('bible7', 'hidden');
275          $form->setType('complement8', 'hidden');          $form->setType('complement8_om_html', 'hidden');
276          $form->setType('bible8', 'hidden');          $form->setType('bible8', 'hidden');
277          $form->setType('complement9', 'hidden');          $form->setType('complement9_om_html', 'hidden');
278          $form->setType('bible9', 'hidden');          $form->setType('bible9', 'hidden');
279          $form->setType('complement10', 'hidden');          $form->setType('complement10_om_html', 'hidden');
280          $form->setType('bible10', 'hidden');          $form->setType('bible10', 'hidden');
281          $form->setType('complement11', 'hidden');          $form->setType('complement11_om_html', 'hidden');
282          $form->setType('bible11', 'hidden');          $form->setType('bible11', 'hidden');
283          $form->setType('complement12', 'hidden');          $form->setType('complement12_om_html', 'hidden');
284          $form->setType('bible12', 'hidden');          $form->setType('bible12', 'hidden');
285          $form->setType('complement13', 'hidden');          $form->setType('complement13_om_html', 'hidden');
286          $form->setType('bible13', 'hidden');          $form->setType('bible13', 'hidden');
287          $form->setType('complement14', 'hidden');          $form->setType('complement14_om_html', 'hidden');
288          $form->setType('bible14', 'hidden');          $form->setType('bible14', 'hidden');
289          $form->setType('complement15', 'hidden');          $form->setType('complement15_om_html', 'hidden');
290          $form->setType('bible15', 'hidden');          $form->setType('bible15', 'hidden');
291          //          //
292          $form->setType('delai', 'hidden');          $form->setType('delai', 'hidden');
# Line 139  class instruction extends instruction_ge Line 295  class instruction extends instruction_ge
295          $form->setType('action', 'hidden');          $form->setType('action', 'hidden');
296          $form->setType('delai_notification', 'hidden');          $form->setType('delai_notification', 'hidden');
297          $form->setType('avis_decision', 'hidden');          $form->setType('avis_decision', 'hidden');
298            $form->setType('autorite_competente', 'hidden');
299          //          //
300          $form->setType('archive_delai', 'hidden');          $form->setType('archive_delai', 'hidden');
301          $form->setType('archive_etat', 'hidden');          $form->setType('archive_etat', 'hidden');
# Line 153  class instruction extends instruction_ge Line 310  class instruction extends instruction_ge
310          $form->setType('archive_date_validite', 'hidden');          $form->setType('archive_date_validite', 'hidden');
311          $form->setType('archive_date_achevement', 'hidden');          $form->setType('archive_date_achevement', 'hidden');
312          $form->setType('archive_date_conformite', 'hidden');          $form->setType('archive_date_conformite', 'hidden');
313          $form->setType('archive_date_chantier', 'hidden');            $form->setType('archive_date_chantier', 'hidden');
314            $form->setType('archive_autorite_competente','hidden');
315          //          //
316          $form->setType('numero_arrete', 'hidden');          $form->setType('numero_arrete', 'hidden');
317            //
318            $form->setType('code_barres', 'hidden');
319                    
320          //          //
321            $form->setType('archive_incompletude','hidden');
322            $form->setType('archive_evenement_suivant_tacite','hidden');
323            $form->setType('archive_evenement_suivant_tacite_incompletude','hidden');
324            $form->setType('archive_etat_pendant_incompletude','hidden');
325            $form->setType('archive_date_limite_incompletude','hidden');
326            $form->setType('archive_delai_incompletude','hidden');
327    
328            //
329            $form->setType('duree_validite','hidden');
330            $form->setType('duree_validite_parametrage','hidden');
331          if ($maj < 2) { //ajouter et modifier          if ($maj < 2) { //ajouter et modifier
332              $form->setType('destinataire', 'hidden');              $form->setType('destinataire', 'hidden');
333              $form->setType('lettretype', 'hiddenstatic');              $form->setType('lettretype', 'hiddenstatic');
334              $form->setType('complement', 'textarea');              $form->setType('complement_om_html', 'html');
335              $form->setType('complement2', 'textarea');              $form->setType('complement2_om_html', 'html');
336              $form->setType('bible_auto', 'httpclick');              $form->setType('bible_auto', 'httpclick');
337              $form->setType('bible', 'httpclick');              $form->setType('bible', 'httpclick');
338              $form->setType('bible2', 'httpclick');              $form->setType('bible2', 'httpclick');
# Line 175  class instruction extends instruction_ge Line 345  class instruction extends instruction_ge
345              $form->setType('date_retour_rar','datedisabled');              $form->setType('date_retour_rar','datedisabled');
346              $form->setType('date_envoi_controle_legalite','datedisabled');              $form->setType('date_envoi_controle_legalite','datedisabled');
347              $form->setType('date_retour_controle_legalite','datedisabled');              $form->setType('date_retour_controle_legalite','datedisabled');
348                $form->setType('date_finalisation_courrier','datedisabled');
349    
350                // l'administrateur peut modifier les champs de retour de date
351                if ($this->f->user_is_admin == true) {
352                    $form->setType('date_retour_signature','date');
353                    $form->setType('date_retour_rar','date');
354                    $form->setType('date_retour_controle_legalite','date');
355                }
356    
357              if($maj==0){ // add              if($maj==0){ // add
358                  $form->setType('instruction', 'hiddenstatic');                  $form->setType('instruction', 'hiddenstatic');
359                  $form->setType('evenement', 'select');                  $form->setType('evenement', 'select');
# Line 199  class instruction extends instruction_ge Line 378  class instruction extends instruction_ge
378              $form->setType('bible', 'hidden');              $form->setType('bible', 'hidden');
379              $form->setType('bible2', 'hidden');              $form->setType('bible2', 'hidden');
380          }          }
381    
382            //Cache les champs pour la finalisation
383            $form->setType('om_fichier_instruction', 'hidden');
384            $form->setType('om_final_instruction', 'hidden');
385            // Cache le document arrêté
386            $form->setType('document_numerise', 'hidden');
387            
388            //Masquer les champs date_envoi_controle_legalite et
389            //date_retour_controle_legalite si ce n'est pas un arrêté
390            if ( !is_numeric($this->getVal("avis_decision"))){
391                
392                $form->setType("date_envoi_controle_legalite", "hidden");
393                $form->setType("date_retour_controle_legalite", "hidden");
394            }
395      }      }
396    
397      function setSelect(&$form, $maj,&$db,$debug) {      function setSelect(&$form, $maj,&$db,$debug) {
# Line 251  class instruction extends instruction_ge Line 444  class instruction extends instruction_ge
444              // du dossier d'instruction en cours              // du dossier d'instruction en cours
445              $sql = "SELECT              $sql = "SELECT
446              evenement.evenement,              evenement.evenement,
447              (evenement.libelle||' ['||evenement.action||']') as lib              CONCAT(evenement.libelle, ' ['||evenement.action||']') as lib
448              FROM ".DB_PREFIXE."dossier              FROM ".DB_PREFIXE."dossier
449              INNER JOIN ".DB_PREFIXE."lien_dossier_instruction_type_evenement              INNER JOIN ".DB_PREFIXE."lien_dossier_instruction_type_evenement
450                  ON dossier.dossier_instruction_type=lien_dossier_instruction_type_evenement.dossier_instruction_type                  ON dossier.dossier_instruction_type=lien_dossier_instruction_type_evenement.dossier_instruction_type
# Line 261  class instruction extends instruction_ge Line 454  class instruction extends instruction_ge
454                  ON evenement.evenement = transition.evenement                  ON evenement.evenement = transition.evenement
455                  AND dossier.etat=transition.etat                  AND dossier.etat=transition.etat
456              WHERE dossier.dossier='".$this->idxformulaire."'              WHERE dossier.dossier='".$this->idxformulaire."'
457              ORDER BY evenement.action";              ORDER BY evenement.libelle, evenement.action";
458              $res = $db->query($sql);              $res = $db->query($sql);
459              $this->addToLog("setSelect(): db->query(\"".$sql."\");", VERBOSE_MODE);              $this->addToLog("setSelect(): db->query(\"".$sql."\");", VERBOSE_MODE);
460              if (database::isError($res)) {              if (database::isError($res)) {
# Line 279  class instruction extends instruction_ge Line 472  class instruction extends instruction_ge
472              $form->setSelect("evenement", $contenu);              $form->setSelect("evenement", $contenu);
473          } else {          } else {
474              $sql = "SELECT              $sql = "SELECT
475              (evenement.libelle||' ['||evenement.action||']') as lib              CONCAT(evenement.libelle, ' ['||evenement.action||']') as lib
476              FROM ".DB_PREFIXE."evenement              FROM ".DB_PREFIXE."evenement
477              WHERE evenement.evenement=".$this->getVal("evenement")."";              WHERE evenement.evenement=".$this->getVal("evenement")."";
478              $res = $db->getone($sql);              $res = $db->getone($sql);
# Line 312  class instruction extends instruction_ge Line 505  class instruction extends instruction_ge
505      function cleSecondaire($id, &$db, $val, $DEBUG) {      function cleSecondaire($id, &$db, $val, $DEBUG) {
506          //          //
507          parent::cleSecondaire($id, $db, $val, $DEBUG);          parent::cleSecondaire($id, $db, $val, $DEBUG);
508            
509            $id = $this->getVal($this->clePrimaire);
510    
511          /**          
512           * Vérification que l'élément supprimé est le dernier pour pouvoir          //Requête de vérification que cet événement d'instruction n'est pas lié
513           * remodifier les données de manière itérative.          //à la création d'un dossier d'instruction
514           */          $sql = "SELECT demande_type.dossier_instruction_type
515          // Initialisation              FROM ".DB_PREFIXE."demande_type
516          $dernierevenement = "";              LEFT JOIN ".DB_PREFIXE."demande
517          // Récupération du dernier élément de la table d'instruction qui              ON demande.demande_type = demande_type.demande_type
518          // concerne le dossier en cours              WHERE demande.instruction_recepisse = ".$id;
519          $sql = "SELECT max(instruction)          $res = $this->db->getOne($sql);
520          FROM ".DB_PREFIXE."instruction          $this->addToLog("cleSecondaire(): db->getone(\"".$sql."\");", VERBOSE_MODE);
521          WHERE dossier ='".$this->idxformulaire."'";          if (database::isError($res)) {
522          $dernierevenement = $db->getOne($sql);              die($res->getMessage());
523          $this->addToLog("setSelect(): db->getone(\"".$sql."\");", VERBOSE_MODE);          }
524          if (database::isError($dernierevenement)) {  
525              die($dernierevenement->getMessage());          // Aucune clé secondaire n'a été trouvée ou c'est un événement sans
526          }          //création de dossier d'instruction, l'événement d'instruction peut être
527          // Si on se trouve effectivement sur le dernier evenement d'instruction          //supprimé
528          if ($dernierevenement == $id) {          if ( $this->correct !== false || $res == null || $res == ""){
529              // Alors on valide la suppression  
530              $this->correct = true;              // Requête de vérification que cet événement d'instruction est lié
531              $this->addToMessage(_('Destruction_chronologique'));              // à une demande
532          } else {              $sql = "SELECT demande
533              // Alors on annule la suppression                  FROM ".DB_PREFIXE."demande
534              $this->correct = false;                  WHERE instruction_recepisse = ".$id;
535              $this->addToMessage(_("Seul le dernier evenement d'instruction peut etre supprime."));              $res = $this->db->getOne($sql);
536                $this->addToLog("cleSecondaire(): db->getone(\"".$sql."\");", VERBOSE_MODE);
537                if (database::isError($res)) {
538                    die($res->getMessage());
539                }
540    
541                //Si c'est un événement d'instruction lié à une demande
542                if ($res != null || $res != ""){
543                    
544                    require_once "../obj/demande.class.php";
545                    $demande = new demande($res, $this->db, DEBUG);
546    
547                    //On met à jour la demande en supprimant la liaison vers
548                    //l'événement d'instruction
549                    $demande->setParameter("maj", 1);
550                    $valF = array();
551                    foreach($demande->champs as $identifiant => $champ) {
552                        $valF[$champ] = $demande->val[$identifiant];
553                    }
554                    $valF['date_demande']=$demande->dateDBToForm($valF['date_demande']);
555                    $valF['instruction_recepisse']=NULL;
556                    $ret = $demande->modifier($valF, $this->db, DEBUG);
557                }
558                    
559                /**
560                 * Vérification que l'élément supprimé est le dernier pour pouvoir
561                 * remodifier les données de manière itérative.
562                 */
563                // Initialisation
564                $dernierevenement = "";
565                // Récupération du dernier élément de la table d'instruction qui
566                // concerne le dossier en cours
567                $sql = "SELECT max(instruction)
568                FROM ".DB_PREFIXE."instruction
569                WHERE dossier ='".$this->idxformulaire."'";
570                $dernierevenement = $db->getOne($sql);
571                $this->addToLog("setSelect(): db->getone(\"".$sql."\");", VERBOSE_MODE);
572                if (database::isError($dernierevenement)) {
573                    die($dernierevenement->getMessage());
574                }
575                // Si on se trouve effectivement sur le dernier evenement d'instruction
576                if ($dernierevenement == $id) {
577                    // Alors on valide la suppression
578                    $this->correct = true;
579                    $this->addToMessage(_('Destruction_chronologique'));
580                } else {
581                    // Alors on annule la suppression
582                    $this->correct = false;
583                    $this->addToMessage(_("Seul le dernier evenement d'instruction peut etre supprime."));
584                }
585          }          }
586      }      }
587    
588      // Vérification de la non modification des dates de suivi      /**
589         * Vérification de la possibilité ou non de modifier des dates de suivi
590         * @param  string $champ champ date à vérifier
591         */
592      function updateDate($champ) {      function updateDate($champ) {
593          if($this->valF[$champ] != "") {          
594              if($this->getVal($champ) != "" AND $this->getVal($champ) != $this->valF[$champ]) {          //Si le retourformulaire est "dossier_instruction"
595                  $this->correct = false;          if ($this->retourformulaire == "dossier_instruction") {
596                  $this->addToMessage(_("Les dates de suivis ne peuvent etre modifiees"));  
597                // Vérification de la possibilité de modifier les dates si déjà éditées
598                if($this->valF[$champ] != "" AND !$this->f->user_is_admin) {
599                    // si l'utilisateur n'est pas un admin
600                    if($this->getVal($champ) != "" AND $this->getVal($champ) != $this->valF[$champ]) {
601                        $this->correct = false;
602                        $this->addToMessage(_("Les dates de suivis ne peuvent etre modifiees"));
603                    }
604              }              }
605          }          }
606            
607            //
608            return true;
609      }      }
610    
611      // Sélectionne le signataire_arrete par défaut      // Sélectionne le signataire_arrete par défaut
# Line 363  class instruction extends instruction_ge Line 620  class instruction extends instruction_ge
620                      WHERE defaut IS TRUE";                      WHERE defaut IS TRUE";
621                            
622              // Exécution de la requête              // Exécution de la requête
             $this->f->addToLog("deleteAllLienDossierInstructionTypeEvenementEvenement(): db->query(\"".$sql."\");", VERBOSE_MODE);  
623              $res = $this->f->db->query($sql);              $res = $this->f->db->query($sql);
624              $this->f->isDatabaseError();              $this->f->addToLog("setVal(): db->query(\"".$sql."\");", VERBOSE_MODE);
625                if ( database::isError($res)){
626                    die();
627                }
628                    
629              $row = $res->fetchrow(DB_FETCHMODE_ASSOC);              $row = $res->fetchrow(DB_FETCHMODE_ASSOC);
630                            
# Line 415  class instruction extends instruction_ge Line 674  class instruction extends instruction_ge
674                            
675              $form->setBloc('date_retour_controle_legalite','F');              $form->setBloc('date_retour_controle_legalite','F');
676    
677              $form->setBloc('complement','D',"","col_12");              $form->setBloc('complement_om_html','D',"","col_12");
678                  $form->setFieldset('complement','D',_('Complement'));                  $form->setFieldset('complement_om_html','D',_('Complement'));
679                  $form->setFieldset('bible','F','');                  $form->setFieldset('bible','F','');
680              $form->setBloc('bible','F');              $form->setBloc('bible','F');
681    
682              $form->setBloc('complement2','D',"","col_12");              $form->setBloc('complement2_om_html','D',"","col_12");
683                  $form->setFieldset('complement2','D',_('Complement 2'));                  $form->setFieldset('complement2_om_html','D',_('Complement 2'));
684                  $form->setFieldset('bible2','F','');                  $form->setFieldset('bible2','F','');
685              $form->setBloc('bible2','F');              $form->setBloc('bible2','F');
686          }          }
# Line 448  class instruction extends instruction_ge Line 707  class instruction extends instruction_ge
707           * - avis_decision           * - avis_decision
708           * - delai_notification           * - delai_notification
709           * - lettretype           * - lettretype
710             * - autorite_competente
711           * DEPUIS LE DOSSIER D'INSTRUCTION           * DEPUIS LE DOSSIER D'INSTRUCTION
712           * - archive_delai           * - archive_delai
713           * - archive_accord_tacite           * - archive_accord_tacite
# Line 462  class instruction extends instruction_ge Line 722  class instruction extends instruction_ge
722           * - date_achevement           * - date_achevement
723           * - date_chantier           * - date_chantier
724           * - date_conformite           * - date_conformite
725             * - avis_decision
726           * Il permet également de stocker la date_depot du dossier d'instruction           * Il permet également de stocker la date_depot du dossier d'instruction
727           * dans l'attribut $this->archive_date_depot de la classe.           * dans l'attribut $this->archive_date_depot de la classe.
728           */           */
# Line 498  class instruction extends instruction_ge Line 759  class instruction extends instruction_ge
759              if(isset($row['avis_decision']) and !empty($row['avis_decision'])) {              if(isset($row['avis_decision']) and !empty($row['avis_decision'])) {
760                  $this->valF['avis_decision']=$row['avis_decision'];                  $this->valF['avis_decision']=$row['avis_decision'];
761              }              }
762                // Récupération de la valeur de l'autorité compétente
763                // si l'autorité compétente est paramétré dans l'événement
764                $this->valF['autorite_competente'] = NULL;
765                if(isset($row['autorite_competente']) and !empty($row['autorite_competente'])) {
766                    $this->valF['autorite_competente']=$row['autorite_competente'];
767                }
768              // Récupération de la valeur de la lettre type              // Récupération de la valeur de la lettre type
769              // Sinon on lui affecte lavaleur par défaut standard              // Sinon on lui affecte lavaleur par défaut standard
770              if ($row['lettretype'] != "") {              if ($row['lettretype'] != "") {
# Line 514  class instruction extends instruction_ge Line 781  class instruction extends instruction_ge
781          if (database::isError($res)) {          if (database::isError($res)) {
782              die($res->getMessage());              die($res->getMessage());
783          }          }
784          while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {          $row=& $res->fetchRow(DB_FETCHMODE_ASSOC);
785              // XXX On stocke la date de dépôt actuelle du dossier d'instruction          $this->updateArchiveData($row);
786              // dans un attribut de la classe          $this->archive_date_depot = $row['date_depot'];
787              $this->archive_date_depot = $row['date_depot'];                  
788              // Récupération de la valeur actuelle du délai, de l'accord tacite,          // Récupération de la duree de validite du dossier d'autorisation
789              // de l'état et de l'avis du dossier d'instruction          $sql = "SELECT duree_validite_parametrage
790              $this->valF['archive_delai']=$row['delai'];                  FROM ".DB_PREFIXE."dossier_autorisation_type_detaille
791              $this->valF['archive_accord_tacite']=$row['accord_tacite'];                  LEFT JOIN ".DB_PREFIXE."dossier_autorisation
792              $this->valF['archive_etat']=$row['etat'];                      ON dossier_autorisation.dossier_autorisation_type_detaille = dossier_autorisation_type_detaille.dossier_autorisation_type_detaille
793              $this->valF['archive_avis']=$row['avis_decision'];                  LEFT JOIN ".DB_PREFIXE."dossier
794              // Récupération de la valeur actuelle des 9 dates du dossier                      ON dossier.dossier_autorisation = dossier_autorisation.dossier_autorisation
795              // d'instruction          WHERE dossier.dossier='".$this->valF['dossier']."'";
796              if ($row['date_complet'] != '') {          $duree_validite_parametrage = $db->getOne($sql);
797                  $this->valF['archive_date_complet']=$row['date_complet'];          $this->addToLog("triggerajouter(): db->getOne(\"".$sql."\");", VERBOSE_MODE);
798              }          database::isError($duree_validite_parametrage);
799              if ($row['date_dernier_depot'] != '') {          if ($duree_validite_parametrage != '') {
800                  $this->valF['archive_date_dernier_depot']=$row['date_dernier_depot'];              $this->valF['duree_validite_parametrage']= $duree_validite_parametrage;
801              }          }
802              if ($row['date_rejet']!='') {  
803                  $this->valF['archive_date_rejet']= $row['date_rejet'];          // Identifiant du type de courrier
804              }          $idTypeCourrier = '11';
805              if ($row['date_limite']!='') {          $idCourrier = str_pad($this->valF["instruction"], 10, "0", STR_PAD_LEFT);
806                  $this->valF['archive_date_limite']= $row['date_limite'];          // Code barres
807              }          $this->valF["code_barres"] = $idTypeCourrier . $idCourrier;
             if ($row['date_notification_delai']!='') {  
                 $this->valF['archive_date_notification_delai']= $row['date_notification_delai'];  
             }  
             if ($row['date_decision']!='') {  
                 $this->valF['archive_date_decision']= $row['date_decision'];  
             }  
             if ($row['date_validite']!='') {  
                 $this->valF['archive_date_validite']= $row['date_validite'];  
             }  
             if ($row['date_achevement']!='') {  
                 $this->valF['archive_date_achevement']= $row['date_achevement'];  
             }  
             if ($row['date_chantier']!='') {  
                 $this->valF['archive_date_chantier']= $row['date_chantier'];  
             }  
             if ($row['date_conformite']!='') {  
                 $this->valF['archive_date_conformite']= $row['date_conformite'];    
             }  
         }  
808      }      }
809            
810      // Test si une restriction est valide      // Test si une restriction est valide
811      // return boolean      // return boolean
812      function restrictionIsValid($restriction){      function restrictionIsValid($restriction){
813    
814            // Liste des opérateurs possible
815            $operateurs = array(">=", "<=", "+", "-");
816            // Liste des opérateurs avec espace
817            $operateurs_blank = array(" >= ", " <= ", " + ", " - ");
818    
819            // Supprime tous les espaces de la chaîne de caractère
820            $restriction = str_replace(' ', '', $restriction);
821                    
822          /* Met des espace avant et après les opérateurs puis transforme la chaine en          // Met des espace avant et après les opérateurs puis transforme la
823           * un tableau */          // chaine en un tableau
824          $tabRestriction = str_replace(">="," >= ",          $tabRestriction = str_replace($operateurs, $operateurs_blank,
825                            str_replace("<="," <= ",              $restriction);
826                            str_replace("-"," - ",          $tabRestriction = explode(" ", $tabRestriction);
827                            str_replace("+"," + ",$restriction))));  
828          $tabRestriction = explode( " ", $tabRestriction);          // Tableau comprenant les résultat
           
         //Variables de résultat  
829          $res = array();          $res = array();
830          $i = 0;          // Compteur pour les résultat
831          $comp = "";          // commence à 1 car le 0 doit rester inchangé tout au long du traitement
832                    $j = 1;
833                    // Comparateur du calcul
834          //Test que le tableau n'est pas vide          $comparateur = '';
835          if ( count($tabRestriction) > 0 ){          // Booléen retourné
836                        $res_bool = true;
837              $res[0] = $this->getRestrictionValue($tabRestriction[0]);  
838                        // S'il y a un comparateur
839              //Calcul des variables          if (in_array(">=", $tabRestriction)
840              for ( $j = 1 ; $j < count($tabRestriction) ; $j += 2 ) {              || in_array("<=", $tabRestriction)) {
841                    
842                  //Variable de comparaison              // Si le tableau n'est pas vide
843                  if ( strcmp( ">=", $tabRestriction[$j] ) == 0 ||              if (count($tabRestriction) > 0) {
844                       strcmp( "<=", $tabRestriction[$j]) ==0 ){  
845                    // Boucle dans le tableau pour récupérer seulement les valeurs
846                    foreach ($tabRestriction as $key => $value) {
847                                            
848                      $comp = $tabRestriction[$j];                      //
849                      $res[++$i] = $this->getRestrictionValue($tabRestriction[$j+1]);                      if (!in_array($value, $operateurs)) {
850                            if ($this->getRestrictionValue($value) != false) {
851                                $res[] = $this->getRestrictionValue($value);
852                            } else {
853                                // Message d'erreur
854                                $error_message = sprintf(_("Le champ %s de l'instruction %s est vide"), "<span class='bold'>".$value."</span>", "<span class='bold'>".$this->valF["instruction"]."</span>");
855                                $this->addToMessage($error_message);
856                                // Arrête le traitement
857                                return false;
858                            }
859                        }
860                  }                  }
861                  // Fait l'addition  
862                  elseif ( strcmp( "+", $tabRestriction[$j]) == 0 ){                  // Boucle dans le tableau
863                    // commence à 1 car le 0 doit rester inchangé tout au long du
864                    // traitement
865                    for ($i = 1; $i<count($tabRestriction); $i++) {
866                                            
867                     $res[$i] =  $this->moisdate( $res[$i], $this->getRestrictionValue($tabRestriction[$j+1]) );                      // Récupère le comparateur
868                        if ($tabRestriction[$i] === ">="
869                            || $tabRestriction[$i] === "<=") {
870                            $comparateur = $tabRestriction[$i];
871                        }
872    
873                        // Si l'opérateur qui suit est un "+"
874                        if ($tabRestriction[$i] === "+") {
875                            $dateDep = $res[$j];
876                            unset($res[$j]);$j++;
877                            $duree = $res[$j];
878                            unset($res[$j]);
879                            $res[$j] = $this->f->mois_date($dateDep, $duree, "+");
880                        }
881    
882                        // Si l'opérateur qui suit est un "-"
883                        if ($tabRestriction[$i] === "-") {
884                            $dateDep = $res[$j];
885                            unset($res[$j]);$j++;
886                            $duree = $res[$j];
887                            unset($res[$j]);
888                            $res[$j] = $this->f->mois_date($dateDep, $duree, "-");
889                        }
890                  }                  }
             }  
         }  
                   
         // Effectue le test  
         if ( strcmp($comp, ">=") == 0 ){  
               
             if ( $res[0] >= $res[1] || $res[0] == "" ){  
891                                    
                 return true;  
892              }              }
             else {  
                   
                 return false;  
             }  
         }  
         elseif ( strcmp($comp, "<=") == 0 ){  
893    
894              if ( $res[0] <= $res[1] || $res[1] == "" ){              // Si les tableau des résultats n'est pas vide
895                if (count($res) > 0) {
896                    //
897                    $res_bool = false;
898                    // Effectue le test
899                    if ($comparateur === ">=") {
900                        //
901                        if (strtotime($res[0]) >= strtotime($res[$j])) {
902                            $res_bool = true;
903                        }
904                    }
905                    if ($comparateur === "<=") {
906    
907                  return true;                      if (strtotime($res[0]) <= strtotime($res[$j])) {
908                            $res_bool = true;
909                        }
910                    }
911              }              }
912              else {          // Sinon une erreur s'affiche
913            } else {
914    
915                  return false;              // Message d'erreur
916              }              $error_message = _("La restriction est sans comparateur");
917                $this->addToMessage($error_message);
918                // Arrête le traitement
919                return false;
920          }          }
921                    
922          return true;          return $res_bool;
923    
924      }      }
925        
926      //Retourne la valeur de valF si $restrictionValue n'est pas un chiffre, le chiffre sinon      /**
927         * Récupère la valeur du champ dans la restriction
928         * @param  string   $restrictionValue   Nom du champ
929         * @return mixed                        Valeur du champ
930         */
931      function getRestrictionValue($restrictionValue){      function getRestrictionValue($restrictionValue){
932            
933          return ( is_numeric($restrictionValue) ) ?          // Initialisation de la valeur de retour
934              $restrictionValue :          $return = false;
935              $this->valF[$restrictionValue];  
936            // Récupére les valeurs du dossier
937            $value_dossier = $this->get_dossier_actual();
938    
939            //
940            if (is_numeric($restrictionValue)) {
941                $return = $restrictionValue;
942            }elseif (isset($value_dossier[$restrictionValue])) {
943                $return = $value_dossier[$restrictionValue];
944            }elseif (isset($this->valF[$restrictionValue])) {
945                $return = $this->valF[$restrictionValue];
946            }
947    
948            // Retourne la valeur du champ
949            return $return;
950      }      }
951            
952      function regle($regle){      function regle($regle){
953            // Supprime tous les espaces de la chaîne de caractère
954            $regle = str_replace(' ', '', $regle);
955            // Coupe la chaîne au niveau des "+"
956          $temp = explode ("+",$regle);          $temp = explode ("+",$regle);
957          //echo '|'.$regle;          //echo '|'.$regle;
958          // cas rejet          // cas rejet
# Line 649  class instruction extends instruction_ge Line 966  class instruction extends instruction_ge
966          if(sizeof($temp)==2){ // 2 dimensions          if(sizeof($temp)==2){ // 2 dimensions
967              if($temp[0]=="archive_date_depot") //initialisation avec le depot              if($temp[0]=="archive_date_depot") //initialisation avec le depot
968                  if(is_numeric($temp[1]))                  if(is_numeric($temp[1]))
969                      return  $this->moisdate($this->$temp[0], $temp[1]);                        return  $this->f->mois_date($this->$temp[0], $temp[1]);  
970                  else                  else
971                      return  $this->moisdate($this->$temp[0], $this->valF[$temp[1]]);                      return  $this->f->mois_date($this->$temp[0], $this->valF[$temp[1]]);
972              if($temp[0]=="archive_delai") // majoration de delai              if($temp[0]=="archive_delai") // majoration de delai
973                  return  $this->valF[$temp[0]]+$this->valF[$temp[1]];                  return  $this->valF[$temp[0]]+$this->valF[$temp[1]];
974              // cas general 2 dimensions              // cas general 2 dimensions
975              if(is_numeric($temp[1]))              if(is_numeric($temp[1]))
976                  return $this->moisdate($this->valF[$temp[0]], $temp[1]);                  return $this->f->mois_date($this->valF[$temp[0]], $temp[1]);
977              else                            else              
978                 return  $this->moisdate($this->valF[$temp[0]], $this->valF[$temp[1]]);                 return  $this->f->mois_date($this->valF[$temp[0]], $this->valF[$temp[1]]);
979          }          }
980          if(sizeof($temp)==3){ // 3 dimensions          if(sizeof($temp)==3){ // 3 dimensions
981              // cas date de validite de sursis              // cas date de validite de sursis
982              if(is_numeric($temp[1]))              if(is_numeric($temp[1]))
983                  $temp1 = $this->moisdate($this->valF[$temp[0]], $temp[1]);                  $temp1 = $this->f->mois_date($this->valF[$temp[0]], $temp[1]);
984              else                            else              
985                  $temp1 = $this->moisdate($this->valF[$temp[0]], $this->valF[$temp[1]]);                  $temp1 = $this->f->mois_date($this->valF[$temp[0]], $this->valF[$temp[1]]);
986              if(is_numeric($temp[2]))              if(is_numeric($temp[2]))
987                  return $this->moisdate($temp1, $temp[2]);                  return $this->f->mois_date($temp1, $temp[2]);
988              else              else
989                  return $this->moisdate($temp1, $this->valF[$temp[2]]);                  return $this->f->mois_date($temp1, $this->valF[$temp[2]]);
990          }          }
991      }      }
992            
# Line 680  class instruction extends instruction_ge Line 997  class instruction extends instruction_ge
997           * Mise à jour des valeurs du dossier en fonction des valeurs calculées           * Mise à jour des valeurs du dossier en fonction des valeurs calculées
998           * par l'action           * par l'action
999           */           */
1000            $this->getValEvenement();
1001          // Initialisation          // Initialisation
1002          $valF = "";          $valF = "";
1003            // état de complétude actuel du dossier
1004            $incompletude =  $this->dossierIncomplet();
1005    
1006            if($incompletude === FALSE) {
1007                // Si l'événement d'instruction est de type incompletude
1008                if($this->valEvenement['type'] == "incompletude") {
1009                    // On marque le dossier en incomplétude pour application des actions
1010                    $incompletude = TRUE;
1011                    // Set du flag incomplétude de la table dossier
1012                    $valF['incompletude'] = TRUE;
1013                    // Enregistrement de l'état dans la variable provisoire
1014                    $valF['etat_pendant_incompletude'] = $this->valF['archive_etat'];
1015                }
1016            } else {
1017                // Si l'evenement d'instruction est de type retour ou contient une
1018                // decision, on sort d'incomplétude
1019                if($this->valEvenement['type'] == "retour" OR
1020                   $this->valEvenement['avis_decision'] != NULL) {
1021                    // On enlève la marque d'incomplétude pour application des actions
1022                    $incompletude = FALSE;
1023                    // On enlève le flag d'incomplétude sur l'enregistrement de la table dossier
1024                    $valF['incompletude'] = FALSE;
1025                     // Restauration de l'état depuis l'état provisoire
1026                    $valF['etat'] = $this->valF['archive_etat_pendant_incompletude'];
1027                    // On vide la variable provisoire ainsi que le délai de complétude
1028                    // et la date limite de complétude
1029                    $valF['etat_pendant_incompletude'] = NULL;
1030                    $valF['delai_incompletude'] = NULL;
1031                    $valF['date_limite_incompletude'] = NULL;
1032                }
1033            }
1034          // Récupération des paramètres de l'action          // Récupération des paramètres de l'action
1035          $sql = "SELECT * FROM ".DB_PREFIXE."action          $sql = "SELECT * FROM ".DB_PREFIXE."action
1036          WHERE action='".$this->valF['action']."'";          WHERE action='".$this->valF['action']."'";
# Line 691  class instruction extends instruction_ge Line 1040  class instruction extends instruction_ge
1040              die($res->getMessage());              die($res->getMessage());
1041          }          }
1042          while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {          while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
1043    
1044              // pour chacune des regles, on applique la regle              // pour chacune des regles, on applique la regle
             if($row['regle_etat']!=''){  
                 $valF['etat'] = $this->regle($row['regle_etat']);  
             }  
1045              if($row['regle_delai']!=''){              if($row['regle_delai']!=''){
1046                  $valF['delai'] = $this->regle($row['regle_delai']);                  $valF['delai'] = $this->regle($row['regle_delai']);
1047              }              }
# Line 734  class instruction extends instruction_ge Line 1081  class instruction extends instruction_ge
1081              if($row['regle_date_conformite']!=''){              if($row['regle_date_conformite']!=''){
1082                  $valF['date_conformite']= $this->regle($row['regle_date_conformite']);                  $valF['date_conformite']= $this->regle($row['regle_date_conformite']);
1083              }              }
1084              // Appel des méthode stockées dans le champ methode_trigger              if($row['regle_date_limite_incompletude']!=''){
1085              if ($row['methode_trigger'] != "") {                  $valF['date_limite_incompletude']= $this->regle($row['regle_date_limite_incompletude']);
1086                  foreach (explode(";", $row['methode_trigger']) as $methode) {              }
1087                      if (method_exists($this, $methode)) {              if($row['regle_delai_incompletude']!=''){
1088                          $this->$methode();                  $valF['delai_incompletude']= $this->regle($row['regle_delai_incompletude']);
1089                      }              }
1090                if($row['regle_autorite_competente']!=''){
1091                    $valF['autorite_competente']= $this->regle($row['regle_autorite_competente']);
1092                }
1093                if($row['regle_etat']!=''){
1094                    // Si on est dans le cas général ou qu'on est en incomplétude et
1095                    // qu'on a un événement de type incomplétude alors : on stocke
1096                    // l'état dans la variable courante
1097                    if ($incompletude == FALSE OR $this->valEvenement['type'] == "incompletude") {
1098                        $valF['etat'] = $this->regle($row['regle_etat']);
1099                    } else {
1100                        $valF['etat_pendant_incompletude'] = $this->regle($row['regle_etat']);
1101                    }
1102                }
1103                if($this->valEvenement['evenement_suivant_tacite'] != '') {
1104                    // Si on est pas en incomplétude on stocke l'événement tacite
1105                    //de l'événement dans la variable courante
1106                    if ($incompletude == FALSE) {
1107                        $valF['evenement_suivant_tacite'] = $this->valEvenement['evenement_suivant_tacite'];
1108                    } else {
1109                        $valF['evenement_suivant_tacite_incompletude'] = $this->valEvenement['evenement_suivant_tacite'];
1110                  }                  }
1111              }              }
1112          }          }
# Line 802  class instruction extends instruction_ge Line 1169  class instruction extends instruction_ge
1169                  }                  }
1170              }              }
1171          } // fin de if ($this->f->getParameter('option_erp') != "")          } // fin de if ($this->f->getParameter('option_erp') != "")
1172    
1173            // Mise à jour des données du dossier d'autorisation
1174            require_once "../obj/dossier_autorisation.class.php";
1175            $da = new dossier_autorisation($this->getNumDemandeAutorFromDossier($this->valF['dossier']), $this->db, DEBUG);
1176            $da->majDossierAutorisation();
1177      }          }    
1178    
1179      function triggermodifierapres($id,&$db,$val,$DEBUG) {      function triggermodifierapres($id,&$db,$val,$DEBUG) {
# Line 811  class instruction extends instruction_ge Line 1183  class instruction extends instruction_ge
1183           */           */
1184          // Initialisation          // Initialisation
1185          $valF = "";          $valF = "";
1186            // Initialisation du type d'événement
1187            $type_evmt = "";
1188          // Récupération de l'action correspondante à l'événement          // Récupération de l'action correspondante à l'événement
1189          $sql = "SELECT action          $sql = "SELECT action
1190          FROM ".DB_PREFIXE."evenement          FROM ".DB_PREFIXE."evenement
# Line 821  class instruction extends instruction_ge Line 1195  class instruction extends instruction_ge
1195              die($action->getMessage());              die($action->getMessage());
1196          }          }
1197    
         // Récupération de tous les paramètres de l'événement sélectionné  
         $sql = "SELECT * FROM ".DB_PREFIXE."evenement  
         WHERE evenement=".$this->valF['evenement'];  
         $res = $db->query($sql);  
         $this->addToLog("triggerajouter(): db->query(\"".$sql."\");", VERBOSE_MODE);  
         if (database::isError($res)) {  
             die($res->getMessage());  
         }  
         while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {  
             // Ajout d'un événement d'instruction  
   
             if ($this->getVal('date_retour_signature') == "" AND $this->valF['date_retour_signature'] != "") {  
                 $new_instruction = new instruction("]", $db, $DEBUG);  
                 foreach($new_instruction->champs as $champ) {  
                     $valNewInstr[$champ] = "";  
                 }  
   
                 $valNewInstr["evenement"] = $row['evenement_retour_signature'];  
                 $valNewInstr["destinataire"] = $this->valF['destinataire'];  
                 $valNewInstr["dossier"] = $this->valF['dossier'];  
                 $valNewInstr["date_evenement"] = date("d/m/Y");  
                 $new_instruction->ajouter($valNewInstr,$db, $DEBUG);  
             }  
         }  
   
1198          // Récupération des paramètres de l'action          // Récupération des paramètres de l'action
1199          $sql = "SELECT * FROM ".DB_PREFIXE."action          $sql = "SELECT * FROM ".DB_PREFIXE."action
1200          WHERE action='".$action."'";          WHERE action='".$action."'";
# Line 892  class instruction extends instruction_ge Line 1241  class instruction extends instruction_ge
1241              // On met à jour le dossier              // On met à jour le dossier
1242              $cle = " dossier='".$this->valF['dossier']."'";              $cle = " dossier='".$this->valF['dossier']."'";
1243              $res1 = $db->autoExecute(DB_PREFIXE.'dossier', $valF, DB_AUTOQUERY_UPDATE, $cle);              $res1 = $db->autoExecute(DB_PREFIXE.'dossier', $valF, DB_AUTOQUERY_UPDATE, $cle);
1244              $this->addToLog("triggerajouterapres(): db->autoexecute(\"".DB_PREFIXE."dossier\", ".print_r($valF, true).", DB_AUTOQUERY_UPDATE, \"".$cle."\");", VERBOSE_MODE);              $this->addToLog("triggermodifierapres(): db->autoexecute(\"".DB_PREFIXE."dossier\", ".print_r($valF, true).", DB_AUTOQUERY_UPDATE, \"".$cle."\");", VERBOSE_MODE);
1245              if (database::isError($res1)) {              if (database::isError($res1)) {
1246                  die($res->getMessage());                  die($res->getMessage());
1247              }              }
# Line 900  class instruction extends instruction_ge Line 1249  class instruction extends instruction_ge
1249              $this->addToMessage(_('enregistrement')." ".$this->valF['dossier']." "._('table')." dossier [".$db->affectedRows()." "._('enregistrement')." "._('mis_a_jour')."]");              $this->addToMessage(_('enregistrement')." ".$this->valF['dossier']." "._('table')." dossier [".$db->affectedRows()." "._('enregistrement')." "._('mis_a_jour')."]");
1250          }          }
1251    
1252            // Récupération de tous les paramètres de l'événement sélectionné
1253            $sql = "SELECT * FROM ".DB_PREFIXE."evenement
1254            WHERE evenement=".$this->valF['evenement'];
1255            $res = $db->query($sql);
1256            $this->addToLog("triggermodifierapres(): db->query(\"".$sql."\");", VERBOSE_MODE);
1257            if (database::isError($res)) {
1258                die($res->getMessage());
1259            }
1260            while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
1261                // Si la date de retour signature est éditée on vérifie si il existe un événement automatique
1262                if ($this->getVal('date_retour_signature') == "" AND
1263                    $this->valF['date_retour_signature'] != "" AND
1264                    $row['evenement_retour_signature'] != "") {
1265                    $new_instruction = new instruction("]", $db, $DEBUG);
1266                    // Création d'un tableau avec la liste des champs de l'instruction
1267                    foreach($new_instruction->champs as $champ) {
1268                        $valNewInstr[$champ] = "";
1269                    }
1270                    // Définition des valeurs de la nouvelle instruction
1271                    $valNewInstr["evenement"] = $row['evenement_retour_signature'];
1272                    $valNewInstr["destinataire"] = $this->valF['destinataire'];
1273                    $valNewInstr["dossier"] = $this->valF['dossier'];
1274                    $valNewInstr["date_evenement"] = $this->f->formatDate($this->valF['date_retour_signature']);
1275                    $valNewInstr["date_envoi_signature"] = $this->f->formatDate($this->valF['date_envoi_signature']);
1276                    $valNewInstr["date_retour_signature"] = $this->f->formatDate($this->valF['date_retour_signature']);
1277                    $valNewInstr["date_envoi_rar"] = $this->f->formatDate($this->valF['date_envoi_rar']);
1278                    $valNewInstr["date_retour_rar"] = $this->f->formatDate($this->valF['date_retour_rar']);
1279                    $valNewInstr["date_envoi_controle_legalite"] = $this->f->formatDate($this->valF['date_envoi_controle_legalite']);
1280                    $valNewInstr["date_retour_controle_legalite"] = $this->f->formatDate($this->valF['date_retour_controle_legalite']);
1281                    $new_instruction->ajouter($valNewInstr,$db, $DEBUG);
1282                }
1283                // Si la date de retour AR est éditée on vérifie si il existe un événement automatique
1284                if ($this->getVal('date_retour_rar') == "" AND
1285                    $this->valF['date_retour_rar'] != "" AND
1286                    $row['evenement_retour_ar'] != "" ) {
1287                    $new_instruction = new instruction("]", $db, $DEBUG);
1288                    // Création d'un tableau avec la liste des champs de l'instruction
1289                    foreach($new_instruction->champs as $champ) {
1290                        $valNewInstr[$champ] = "";
1291                    }
1292                    // Définition des valeurs de la nouvelle instruction
1293                    $valNewInstr["evenement"] = $row['evenement_retour_ar'];
1294                    $valNewInstr["destinataire"] = $this->valF['destinataire'];
1295                    $valNewInstr["dossier"] = $this->valF['dossier'];
1296                    $valNewInstr["date_evenement"] = $this->f->formatDate($this->valF['date_retour_rar']);
1297                    $valNewInstr["date_envoi_signature"] = $this->f->formatDate($this->valF['date_envoi_signature']);
1298                    $valNewInstr["date_retour_signature"] = $this->f->formatDate($this->valF['date_retour_signature']);
1299                    $valNewInstr["date_envoi_rar"] = $this->f->formatDate($this->valF['date_envoi_rar']);
1300                    $valNewInstr["date_retour_rar"] = $this->f->formatDate($this->valF['date_retour_rar']);
1301                    $valNewInstr["date_envoi_controle_legalite"] = $this->f->formatDate($this->valF['date_envoi_controle_legalite']);
1302                    $valNewInstr["date_retour_controle_legalite"] = $this->f->formatDate($this->valF['date_retour_controle_legalite']);
1303                    $new_instruction->ajouter($valNewInstr,$db, $DEBUG);
1304                }
1305            }
1306    
1307          /**          /**
1308           * REFERENTIEL ARRETE           * REFERENTIEL ARRETE
1309           */           */
1310          if ($this->f->getParameter('option_referentiel_arrete') != "") {          // Si l'option référentiel arrêté est activé et l'événement est de type
1311            // arrêté
1312            if ($this->f->getParameter('option_referentiel_arrete') != "" AND
1313                $type_evmt == "arrete") {
1314              if ($this->valF['date_retour_signature'] != $this->getVal('date_retour_signature')) {              if ($this->valF['date_retour_signature'] != $this->getVal('date_retour_signature')) {
1315                  $msgenque = new MessageEnqueuer();                  $msgenque = new MessageEnqueuer();
1316                  $sqlArrete = "SELECT instruction.signataire_arrete as \"ws_DA_In_Signataire\",                  $sqlArrete = "SELECT instruction.signataire_arrete as \"ws_DA_In_Signataire\",
# Line 916  class instruction extends instruction_ge Line 1323  class instruction extends instruction_ge
1323                                      '' as \"ws_DA_In_Sigle\",                                      '' as \"ws_DA_In_Sigle\",
1324                                      instruction.etat as \"ws_DA_In_Decision\",                                      instruction.etat as \"ws_DA_In_Decision\",
1325                                      dossier.date_depot as \"ws_DA_In_Dte_Depot_Dem\",                                      dossier.date_depot as \"ws_DA_In_Dte_Depot_Dem\",
1326                                      dossier.terrain_numero as \"ws_DA_In_N_Voie\",                                      dossier.terrain_adresse_voie_numero as \"ws_DA_In_N_Voie\",
1327                                      '' as \"ws_DA_In_Type_Voie\",                                      '' as \"ws_DA_In_Type_Voie\",
1328                                      dossier.complement as \"ws_DA_In_Adresse1\",                                      dossier.terrain_adresse_voie as \"ws_DA_In_Adresse1\",
1329                                      dossier.terrain_adresse_lieu_dit as \"ws_DA_In_Adresse2\",                                      dossier.terrain_adresse_lieu_dit as \"ws_DA_In_Adresse2\",
1330                                      dossier.terrain_adresse_code_postal as \"ws_DA_In_CP\",                                      dossier.terrain_adresse_code_postal as \"ws_DA_In_CP\",
1331                                      dossier.terrain_adresse_localite as \"ws_DA_In_Ville\",                                      dossier.terrain_adresse_localite as \"ws_DA_In_Ville\",
# Line 949  class instruction extends instruction_ge Line 1356  class instruction extends instruction_ge
1356                                      donnees_techniques.dossier_instruction = dossier.dossier                                      donnees_techniques.dossier_instruction = dossier.dossier
1357                              WHERE instruction.instruction = ".$this->valF['instruction'];                              WHERE instruction.instruction = ".$this->valF['instruction'];
1358                  $resArrete = $this->db->query($sqlArrete);                  $resArrete = $this->db->query($sqlArrete);
1359                  $this->f->addToLog("triggerModifierApres(): db->query(\"".$sqlArrete."\");", VERBOSE_MODE);                  $this->f->addToLog("triggermodifierapres(): db->query(\"".$sqlArrete."\");", VERBOSE_MODE);
1360                  $this->f->isDatabaseError();                  if ( database::isError($resArrete)){
1361                        die();
1362                    }
1363            
1364                  $rowArrete = $resArrete->fetchRow(DB_FETCHMODE_ASSOC);                  $rowArrete = $resArrete->fetchRow(DB_FETCHMODE_ASSOC);
1365                  $msgenque->setArreteInfo($rowArrete);                  $msgenque->setArreteInfo($rowArrete);
1366                  $msgenque->enqueueMessage($msgenque::$ARRETE_ENVOI);                                  $msgenque->enqueueMessage($msgenque::$ARRETE_ENVOI);                
1367              }              }
1368          }          }
1369    
1370            // Mise à jour des données du dossier d'autorisation
1371            require_once "../obj/dossier_autorisation.class.php";
1372            $da = new dossier_autorisation($this->getNumDemandeAutorFromDossier($this->valF['dossier']), $this->db, DEBUG);
1373            $da->majDossierAutorisation();
1374      }      }
1375    
1376      function triggersupprimer($id,&$db,$val,$DEBUG) {      function triggersupprimer($id,&$db,$val,$DEBUG) {
# Line 965  class instruction extends instruction_ge Line 1379  class instruction extends instruction_ge
1379           * archive dans le dossier d'instruction avant de supprimer l'événement           * archive dans le dossier d'instruction avant de supprimer l'événement
1380           * d'instruction           * d'instruction
1381           */           */
1382          // archive en instruction (si suppression) [archive if delete instruction]          
1383          $valF['delai']=$val['archive_delai'];              // Mise à jour des 4 valeurs modifiées par l'action
1384          $valF['accord_tacite']=$val['archive_accord_tacite'];              $valF['delai'] = $val['archive_delai'];
1385          $valF['etat']=$val['archive_etat'];              $valF['accord_tacite'] = $val['archive_accord_tacite'];
1386          if($val['archive_avis']=='')              $valF['etat'] = $val['archive_etat'];
1387              $valF['avis_decision']= null;              if ($val['archive_avis'] != '') {
1388          else                  $valF['avis_decision'] = $val['archive_avis'];
1389              $valF['avis_decision']=$val['archive_avis'];              } else {
1390          if($val['archive_date_complet']!='')                  $valF['avis_decision'] = NULL;
1391              $valF['date_complet']=$val['archive_date_complet'];              }
1392          if($val['archive_date_dernier_depot']!='')              // Mise à jour des 10 dates avec la valeur présente dans le formulaire
1393              $valF['date_dernier_depot']=$val['archive_date_dernier_depot'];              // de suppression. Si la valeur de la date est vide alors on fixe
1394          if($val['archive_date_rejet']!='')              // à la valeur NULL
1395              $valF['date_rejet']= $val['archive_date_rejet'];              //
1396          if($val['archive_date_limite']!='')              if ($val['archive_date_complet'] != '') {
1397              $valF['date_limite']= $val['archive_date_limite'];                  $valF['date_complet'] = $val['archive_date_complet'];
1398          if($val['archive_date_notification_delai']!='')              } else {
1399              $valF['date_notification_delai']= $val['archive_date_notification_delai'];                  $valF['date_complet'] = NULL;
1400          if($val['archive_date_decision']!='')              }
1401              $valF['date_decision']= $val['archive_date_decision'];              if ($val['archive_date_dernier_depot'] != '') {
1402          if($val['archive_date_validite']!='')                  $valF['date_dernier_depot'] = $val['archive_date_dernier_depot'];
1403              $valF['date_validite']= $val['archive_date_validite'];              } else {
1404          if($val['archive_date_achevement']!='')                  $valF['date_dernier_depot'] = NULL;
1405              $valF['date_achevement']= $val['archive_date_achevement'];              }
1406          if($val['archive_date_chantier']!='')              if ($val['archive_date_rejet'] != '') {
1407              $valF['date_chantier']= $val['archive_date_chantier'];                  $valF['date_rejet'] = $val['archive_date_rejet'];
1408          if($val['archive_date_conformite']!='')              } else {
1409              $valF['date_conformite']= $val['archive_date_conformite'];                  $valF['date_rejet'] = NULL;
1410          // On met à jour le dossier              }
1411          $cle = " dossier='".$val['dossier']."'";              if ($val['archive_date_limite'] != '') {
1412          $res1 = $db->autoExecute(DB_PREFIXE.'dossier', $valF, DB_AUTOQUERY_UPDATE, $cle);                  $valF['date_limite'] = $val['archive_date_limite'];
1413          $this->addToLog("triggersupprimer(): db->autoexecute(\"".DB_PREFIXE."dossier\", ".print_r($valF, true).", DB_AUTOQUERY_UPDATE, \"".$cle."\");", VERBOSE_MODE);              } else {
1414          if (database::isError($res1)) {                  $valF['date_limite'] = NULL;
1415              die($res->getMessage());              }
1416          }              if ($val['archive_date_notification_delai'] != '') {
1417          // Affichage d'informations à l'utilisateur                  $valF['date_notification_delai'] = $val['archive_date_notification_delai'];
1418          $this->addToMessage(_("Suppression de l'instruction")." [".$db->affectedRows()." "._('enregistrement')." "._('mis_a_jour')."]");              } else {
1419                    $valF['date_notification_delai'] = NULL;
1420                }
1421                if ($val['archive_date_decision'] != '') {
1422                    $valF['date_decision'] = $val['archive_date_decision'];
1423                } else {
1424                    $valF['date_decision'] = NULL;
1425                }
1426                if ($val['archive_date_validite'] != '') {
1427                    $valF['date_validite'] = $val['archive_date_validite'];
1428                } else {
1429                    $valF['date_validite'] = NULL;
1430                }
1431                if ($val['archive_date_achevement'] != '') {
1432                    $valF['date_achevement'] = $val['archive_date_achevement'];
1433                } else {
1434                    $valF['date_achevement'] = NULL;
1435                }
1436                if ($val['archive_date_chantier'] != '') {
1437                    $valF['date_chantier'] = $val['archive_date_chantier'];
1438                } else {
1439                    $valF['date_chantier'] = NULL;
1440                }
1441                if ($val['archive_date_conformite'] != '') {
1442                    $valF['date_conformite'] = $val['archive_date_conformite'];
1443                } else {
1444                    $valF['date_conformite'] = NULL;
1445                }
1446                if ($val['archive_incompletude'] != '') {
1447                    $valF['incompletude'] = $val['archive_incompletude'];
1448                } else {
1449                    $valF['incompletude'] = NULL;
1450                }
1451                if ($val['archive_evenement_suivant_tacite'] != '') {
1452                    $valF['evenement_suivant_tacite'] = $val['archive_evenement_suivant_tacite'];
1453                } else {
1454                    $valF['evenement_suivant_tacite'] = NULL;
1455                }
1456                if ($val['archive_evenement_suivant_tacite_incompletude'] != '') {
1457                    $valF['evenement_suivant_tacite_incompletude'] = $val['archive_evenement_suivant_tacite_incompletude'];
1458                } else {
1459                    $valF['evenement_suivant_tacite_incompletude'] = NULL;
1460                }
1461                if ($val['archive_etat_pendant_incompletude'] != '') {
1462                    $valF['etat_pendant_incompletude'] = $val['archive_etat_pendant_incompletude'];
1463                } else {
1464                    $valF['etat_pendant_incompletude'] = NULL;
1465                }
1466                if ($val['archive_date_limite_incompletude'] != '') {
1467                    $valF['date_limite_incompletude'] = $val['archive_date_limite_incompletude'];
1468                } else {
1469                    $valF['date_limite_incompletude'] = NULL;
1470                }
1471                if ($val['archive_delai_incompletude'] != '') {
1472                    $valF['delai_incompletude'] = $val['archive_delai_incompletude'];
1473                } else {
1474                    $valF['delai_incompletude'] = NULL;
1475                }
1476                if ($val['archive_autorite_competente'] != '') {
1477                    $valF['autorite_competente'] = $val['archive_autorite_competente'];
1478                } else {
1479                    $valF['autorite_competente'] = NULL;
1480                }
1481                // On met à jour le dossier
1482                $cle = " dossier='".$val['dossier']."'";
1483                $res = $db->autoExecute(DB_PREFIXE.'dossier', $valF, DB_AUTOQUERY_UPDATE, $cle);
1484                $this->addToLog("triggersupprimer(): db->autoexecute(\"".DB_PREFIXE."dossier\", ".print_r($valF, true).", DB_AUTOQUERY_UPDATE, \"".$cle."\");", VERBOSE_MODE);
1485                if (database::isError($res)) {
1486                    die($res->getMessage());
1487                }
1488                // Affichage d'informations à l'utilisateur
1489                $this->addToMessage(_("Suppression de l'instruction")." [".$db->affectedRows()." "._('enregistrement')." "._('mis_a_jour')."]");
1490        
1491                // Mise à jour de la demande si un récépissé d'instruction correspond à l'instruction à supprimer
1492      }      }
1493    
1494      // =============================================      function triggersupprimerapres($id,&$db,$val,$DEBUG) {
1495      // calcul de date avec ajout de mois (delais)  
1496      // [add months (delay) and calculation final date]          // Mise à jour des données du dossier d'autorisation
1497      // LIMITE DE LA FONCTION si delai >24 MOIS          require_once "../obj/dossier_autorisation.class.php";
1498      // [limit : delay < 24 month]          $da = new dossier_autorisation($this->getNumDemandeAutorFromDossier($val["dossier"]), $this->db, DEBUG);
1499      // =============================================          $da->majDossierAutorisation();
     function moisdate($date,$delaimois) {  
        $temp = explode("-" , $date);  
        $jour = (int) $temp[2];  
        $mois = (int) $temp[1];  
        $annee = (int) $temp[0];  
        // calcul si delai superieur à 12 (limite 24) [delay > 24 month]  
        if($delaimois>=12){  
            $delaimois=$delaimois-12;  
            $annee=$annee+1;  
        }  
        if($delaimois>=12){  
            $delaimois=$delaimois-12;  
            $annee=$annee+1;  
        }  
        // mois  
        $mois=$mois+$delaimois;  
        // calcul mois annee  [calculation number of years if > 12 month]  
        // nb de mois > à 12  
        if ($mois>12){  
            $mois=$mois-12;  
            $annee=$annee+1;  
        }  
        // Calcul du nombre de jours dans le mois sélectionné [calculation number of days]  
         switch($mois) {  
             case "2":  
               if ($annee % 4 == 0 && $annee % 100 != 0 || $annee % 400 == 0)  
                   $jourmax = 29;  
               else  
                   $jourmax = 28;  
             break;  
             case "4":  
             case "6":  
             case "9":  
             case "11":  
              $jourmax = 30;  
              break;  
             default:  
              $jourmax = 31;  
         }  
         if ($jour > $jourmax)  
            $jour = $jourmax;  
     //$dateretour=$annee."-".$mois."-".$jour;  
     return $annee."-".$mois."-".$jour ;  
1500      }      }
1501    
1502      // Vérifie la restriction sur l'événement      // Vérifie la restriction sur l'événement
1503      function verifier($val = array(), &$db, $DEBUG){      function verifier($val = array(), &$db, $DEBUG){
1504          parent::verifier($val, $db, $DEBUG);          parent::verifier($val, $db, $DEBUG);
         //Récupère la restriction  
         $sql= "SELECT  
                   restriction  
               FROM  
                   ".DB_PREFIXE."evenement  
               WHERE  
                   evenement =".$this->valF['evenement'];  
1505    
1506          $res = $db->query($sql);          if ( isset($val['evenement']) && is_numeric($val['evenement'])){
1507          $this->f->addToLog("verifier(): db->query(\"".$sql."\");", VERBOSE_MODE);              //Récupère la restriction
1508          $this->f->isDatabaseError();              $sql= "SELECT
1509                                  restriction
1510          $row=& $res->fetchRow(DB_FETCHMODE_ASSOC);                    FROM
1511                          ".DB_PREFIXE."evenement
1512                      WHERE
1513                          evenement =".$val['evenement'];
1514        
1515                $res = $db->query($sql);
1516                $this->addToLog("verifier(): db->query(\"".$sql."\");", VERBOSE_MODE);
1517                if (database::isError($res)) {
1518                    die($res->getMessage());
1519                }        
1520                $row=& $res->fetchRow(DB_FETCHMODE_ASSOC);
1521        
1522                //Test qu'une restriction est présente
1523                if ( isset($row['restriction']) && $row['restriction'] != "" ){
1524    
1525          //Test qu'une restriction est présente                  $restriction = $row['restriction'];
         if ( isset($row['restriction']) && $row['restriction'] != "" ){  
               
             //Test si la restriction est valide  
             if ( !$this->restrictionIsValid($row['restriction']) ){  
1526                                    
1527                  $this->correct=false;                  //Test si la restriction est valide
1528                  $this->addToMessage(_("Restriction non valide"));                  if ( !$this->restrictionIsValid($restriction) ){
1529              }                      
1530              else {                      $this->correct=false;
1531                        $this->addToMessage(_("Restriction non valide"));
1532                    }
1533                    else {
1534                        
1535                        $this->correct = true;
1536                    }
1537    
1538                    // Liste des opérateurs possible
1539                    $operateurs = array(">=", "<=", "+", "-");
1540    
1541                    // Supprime tous les espaces de la chaîne de caractère
1542                    $restriction = str_replace(' ', '', $restriction);
1543                                    
1544                  $this->correct = true;                  // Met des espace avant et après les opérateurs puis transforme la
1545                    // chaine en un tableau
1546                    $tabRestriction = str_replace($operateurs, " ", $restriction);
1547                    // Tableau des champ
1548                    $tabRestriction = explode(" ", $tabRestriction);
1549                    // Supprime les numériques du tableau
1550                    foreach ($tabRestriction as $key => $value) {
1551                        if (is_numeric($value)) {
1552                            unset($tabRestriction[$key]);
1553                        }
1554                    }
1555    
1556                    // Vérifie les champs utilisés pour la restriction
1557                    $check_field_exist = $this->f->check_field_exist($tabRestriction, 'instruction');
1558                    if ($check_field_exist !== true) {
1559    
1560                        // Liste des champs en erreur
1561                        $string_error_fields = implode(", ", $check_field_exist);
1562    
1563                        // Message d'erreur
1564                        $error_message = _("Le champ %s n'est pas utilisable pour le champ %s");
1565                        if (count($check_field_exist) > 1) {
1566                            $error_message = _("Les champs %s ne sont pas utilisable pour le champ %s");
1567                        }
1568    
1569                        // Affiche l'erreur
1570                        $this->correct=false;
1571                        $this->addToMessage(sprintf($error_message, $string_error_fields, _("restriction")));
1572                        $this->addToMessage(_("Veuillez contacter votre administrateur."));
1573                    }
1574              }              }
1575    
1576            }
1577            if(!$this->updateDate("date_envoi_signature")) {
1578                return false;
1579            }
1580            if(!$this->updateDate("date_retour_signature")) {
1581                return false;
1582            }
1583            if(!$this->updateDate("date_envoi_rar")) {
1584                return false;
1585            }
1586            if(!$this->updateDate("date_retour_rar")) {
1587                return false;
1588            }
1589            if(!$this->updateDate("date_envoi_controle_legalite")) {
1590                return false;
1591            }
1592            if(!$this->updateDate("date_retour_controle_legalite")) {
1593                return false;
1594          }          }
1595    
         $this->updateDate("date_envoi_signature");  
         $this->updateDate("date_retour_signature");  
         $this->updateDate("date_envoi_rar");  
         $this->updateDate("date_retour_rar");  
         $this->updateDate("date_envoi_controle_legalite");  
         $this->updateDate("date_retour_controle_legalite");  
1596      }      }
1597        
1598      /**      /**
1599       * Méthode permettant de mettre à jour l'état d'un DA       * Méthode permettant de récupérer toutes les valeurs de l'événement
1600         * sélectionné après validation du formulaire d'instruction
1601         *
1602         * @return array() veleurs de l'événement lié
1603       */       */
1604      function majEtatDA() {  
1605          if($this->valF['action'] == 'accepter' AND $this->valF['avis_decision'] == 8) {      private function getValEvenement() {
1606              $val['etat_dossier_autorisation']=5;          if(!empty($this->valEvenement)) {
1607          } elseif($this->valF['action'] == 'accepter' AND $this->valF['avis_decision'] == 15) {              return $this->valEvenement;
             $val['etat_dossier_autorisation']=3;  
         } elseif($this->valF['action'] == 'accepter') {  
             $val['etat_dossier_autorisation']=2;  
         } elseif($this->valF['action'] == 'rejeter') {  
             $val['etat_dossier_autorisation']=4;  
         } elseif($this->valF['action'] == 'terminer') {  
             $val['etat_dossier_autorisation']=8;  
         } elseif($this->valF['action'] == 'majorer') {  
             $val['etat_dossier_autorisation']=6;  
1608          } else {          } else {
1609              $val['etat_dossier_autorisation']=7;              $sql = "SELECT * FROM ".DB_PREFIXE."evenement
1610                    WHERE evenement=".$this->valF['evenement'];
1611                $res = $this->db->query($sql);
1612                $this->addToLog("getValEvenement(): db->query(\"".$sql."\");", VERBOSE_MODE);
1613                if (database::isError($res)) {
1614                    die($res->getMessage());
1615                }
1616                $this->valEvenement = $res->fetchRow(DB_FETCHMODE_ASSOC);
1617                return $this->valEvenement;
1618          }          }
1619                }
1620          //Récupération du numéro de dossier d'autorisation lié au dossier d'instruction  
1621          $IDdossier_autorisation = $this->getDossierAutorisation($this->valF['dossier']);      /**
1622               * Méthode permettant de savoir si le dossier lié à l'instruction à le flag
1623          // Mis à jour de l'état du dossier d'autorisation       * incompletude à true après validation du formulaire d'instruction
1624          require_once '../obj/dossier_autorisation.class.php';       *
1625          $dossier_autorisation = new dossier_autorisation($IDdossier_autorisation,$this->db,DEBUG);       * @return boolean
1626                 */
1627          $dossier_autorisation->val[array_search("etat_dossier_autorisation", $dossier_autorisation->champs)] = $val['etat_dossier_autorisation'];      private function dossierIncomplet() {
1628                    $sql = "SELECT incompletude FROM ".DB_PREFIXE."dossier
1629          //Récupération des données                  WHERE dossier='".$this->valF['dossier']."'";
1630          $valDossierAutorisation = array();          $incompletude = $this->db->getOne($sql);
1631          for ( $i=0 ; $i<count($dossier_autorisation->champs); $i++){          $this->addToLog("dossierIncomplet(): db->query(\"".$sql."\");", VERBOSE_MODE);
1632            if (database::isError($incompletude)) {
1633                die($incompletude->getMessage());
1634            }
1635            if ($incompletude == 't') {
1636                return true;
1637            } else {
1638                return false;
1639            }
1640        }
1641        
1642        /**
1643         * Finalisation des documents.
1644         * @param  string $champ    champ du fichier à finaliser
1645         * @param  booleen $status  permet de définir si on finalise ou définalise
1646         * @param  string $sousform permet de savoir si se trouve dans un sousformulaire (passé au javascript)
1647         */
1648        function finaliser( $champ = '', $status, $sousform, $retourformulaire){
1649    
1650            //Si on finalise le document
1651            if ( $status == 1 ){
1652                
1653                //Génération du PDF
1654                $_GET['output'] = "string";
1655                $f = $this->f;
1656                include '../app/pdf_instruction.php';
1657                
1658                //Métadonnées du document
1659                $metadata = array(
1660                    'filename' => 'instruction_'.$idx.'.pdf',
1661                    'mimetype' => 'application/pdf',
1662                    'size' => strlen($pdf_output)
1663                );
1664    
1665                // Récupération des métadonnées calculées après validation
1666                $spe_metadata = $this->getMetadata("om_fichier_instruction");
1667    
1668                $metadata = array_merge($metadata, $spe_metadata);
1669                //Si le document a déjà été finalisé
1670                //on met à jour le document mais pas son uid
1671                if ( $this->getVal("om_fichier_instruction") != '' ){
1672                    $uid = $this->f->storage->update(
1673                        $this->getVal("om_fichier_instruction"), $pdf_output, $metadata);
1674                }
1675                //Sinon, on joute le document et on récupère son uid
1676                else {
1677                    //Stockage du PDF
1678                    $uid = $this->f->storage->create($pdf_output, $metadata);
1679                }
1680            }
1681            else {
1682                //Récupération de l'uid du document finalisé
1683                $uid = $this->getVal("om_fichier_instruction");
1684                            
1685              $valDossierAutorisation[$dossier_autorisation->champs[$i]]=              //On dé-finalise avant de finaliser
1686                  $dossier_autorisation->val[$i];              if ( $uid == '' || $uid == 'OP_FAILURE' ){
1687                    return -1;
1688                }
1689          }          }
1690    
1691          $dossier_autorisation->modifier($valDossierAutorisation, $this->db, DEBUG);          //Mise à jour des données
1692      }          if ( $uid != '' || $uid == 'OP_FAILURE' ){
1693                    // Logger
1694     /**              $this->addToLog("finaliser() - begin", EXTRA_VERBOSE_MODE);
1695      * Méthode permettant de mettre à jour les données d'un DA              // Recuperation de la valeur de la cle primaire de l'objet
1696      */              if($this->getVal($this->clePrimaire) != '')
1697      function majDataDA() {                  $id = $this->getVal($this->clePrimaire);
1698                        else
1699          //Récupération du numéro de dossier d'autorisation lié au dossier d'instruction                  $id=$this->id;
         $IDdossier_autorisation = $this->getDossierAutorisation($this->valF['dossier']);  
         require_once '../obj/dossier_autorisation.class.php';  
         $dossier_autorisation = new dossier_autorisation($IDdossier_autorisation,$this->db,DEBUG);  
           
         require_once '../obj/dossier.class.php';  
         $dossier = new dossier($this->valF['dossier'],$this->db,DEBUG);  
           
         //Récupération des données  
         $valDossierAutorisation = array();  
         for ( $i=0 ; $i<count($dossier_autorisation->champs); $i++){  
1700                            
1701              if ( array_search($dossier_autorisation->champs[$i], $dossier->champs) ){              $actions = array();
1702                //Tableau contenant le lien vers le PDF et lien du portlet pour la mise
1703                //à jour de l'interface
1704                if ( $status == 0 ){
1705                    $lien = '../app/pdf_instruction.php?idx='.$id;
1706                                    
1707                  $valDossierAutorisation[$dossier_autorisation->champs[$i]]=$dossier->getVal($dossier_autorisation->champs[$i]);                  //Ajout des actions
1708                    //Si l'utilisateur a le droit de modifier l'objet
1709                    if ( $this->f->isAccredited('instruction') ||
1710                        $this->f->isAccredited('instruction_modifier') ){
1711                            
1712                        $actions["modifier"] = ($sousform!='')?
1713                            '<li><a href="#" onclick="ajaxIt(\'instruction\',
1714                            \'../scr/sousform.php?obj=instruction&amp;action=1&amp;idx='.
1715                            $this->getVal($this->clePrimaire).
1716                            '&amp;premiersf=0&amp;trisf=&amp;retourformulaire='.$retourformulaire.'&amp;idxformulaire='.
1717                            $this->getVal("dossier").
1718                            '&amp;retour=form\');">
1719                            <span class="om-prev-icon om-icon-16 edit-16" title="'.
1720                            _('Modifier').'">'.
1721                            _('Modifier').
1722                            '</span></a></li>':
1723                            '<li>
1724                            <a href="form.php?obj=instruction&amp;action=1'.'&amp;idx='.
1725                            $this->getVal($this->clePrimaire).
1726                            '&amp;premier=&amp;advs_id=&amp;recherche=&amp;tricol=&amp;selectioncol=&amp;valide=&amp;retour=form">
1727                            <span class="om-prev-icon om-icon-16 edit-16" title="'.
1728                            _('Modifier').'">'.
1729                            _('Modifier').
1730                            '</span></a></li>';
1731                    }
1732                    //Si l'utilisateur a le droit de supprimer l'objet
1733                    if ( $this->f->isAccredited('instruction') ||
1734                        $this->f->isAccredited('instruction_supprimer') ){
1735                            
1736                        $actions["supprimer"] = ($sousform!='')?
1737                            '<li><a href="#" onclick="ajaxIt(\'instruction\',
1738                            \'../scr/sousform.php?obj=instruction&amp;action=2&amp;idx='.
1739                            $this->getVal($this->clePrimaire).
1740                            '&amp;premiersf=0&amp;trisf=&amp;retourformulaire='.$retourformulaire.'&amp;idxformulaire='.
1741                            $this->getVal("dossier").
1742                            '&amp;retour=form\');">
1743                            <span class="om-prev-icon om-icon-16 delete-16" title="'.
1744                            _('Supprimer').'">'.
1745                            _('Supprimer').
1746                            '</span></a></li>':
1747                            '<li>
1748                            <a href="form.php?obj=instruction&amp;action=1'.'&amp;idx='.
1749                            $this->getVal($this->clePrimaire).
1750                            '&amp;premier=&amp;advs_id=&amp;recherche=&amp;tricol=&amp;selectioncol=&amp;valide=&amp;retour=form">
1751                            <span class="om-prev-icon om-icon-16 delete-16" title="'.
1752                            _('Supprimer').'">'.
1753                            _('Supprimer').
1754                            '</span></a></li>';
1755                    }
1756              }              }
1757              else {              else {
1758                  $valDossierAutorisation[$dossier_autorisation->champs[$i]]=                  $lien = '../spg/file.php?obj=instruction&'.
1759                  $dossier_autorisation->val[$i];                      'champ=om_fichier_instruction&id='.$id;
1760              }              }
1761    
1762               $retour = array(
1763                    "portlet"=> "<a href=\"#\" onclick=\"finalizeDocument(".
1764                        $id.", 'instruction', '".$sousform."', ".(($status==0)?1:0).")\">
1765                        <span class=\"om-prev-icon om-icon-16 om-icon-fix "
1766                        .(($status==1)?"de":"")."finalise\" title=\"".
1767                        (($status==1)?_("Reprendre la redaction du document"):_("Finaliser le document"))."\">".
1768                        (($status==1)?_("Reprendre la redaction du document"):_("Finaliser le document"))."</span>
1769                        </a>",
1770                    "pdf" => $lien,
1771                    "actions" => $actions
1772                );
1773    
1774                foreach ( $this->champs as $key=>$value )
1775                    $val[$value] = $this->val[$key];
1776                $val['date_evenement']=$this->dateDBToForm($val['date_evenement']);
1777                $val['archive_date_complet']=$this->dateDBToForm($val['archive_date_complet']);
1778                $val['archive_date_rejet']=$this->dateDBToForm($val['archive_date_rejet']);
1779                $val['archive_date_limite']=$this->dateDBToForm($val['archive_date_limite']);
1780                $val['archive_date_notification_delai']=$this->dateDBToForm($val['archive_date_notification_delai']);
1781                $val['archive_date_decision']=$this->dateDBToForm($val['archive_date_decision']);
1782                $val['archive_date_validite']=$this->dateDBToForm($val['archive_date_validite']);
1783                $val['archive_date_achevement']=$this->dateDBToForm($val['archive_date_achevement']);
1784                $val['archive_date_chantier']=$this->dateDBToForm($val['archive_date_chantier']);
1785                $val['archive_date_conformite']=$this->dateDBToForm($val['archive_date_conformite']);
1786                $val['archive_date_dernier_depot']=$this->dateDBToForm($val['archive_date_dernier_depot']);
1787                $val['archive_date_limite_incompletude']=$this->dateDBToForm($val['archive_date_limite_incompletude']);
1788                $val['date_finalisation_courrier']=$this->dateDBToForm($val['date_finalisation_courrier']);
1789                $val['date_envoi_signature']=$this->dateDBToForm($val['date_envoi_signature']);
1790                $val['date_retour_signature']=$this->dateDBToForm($val['date_retour_signature']);
1791                $val['date_envoi_rar']=$this->dateDBToForm($val['date_envoi_rar']);
1792                $val['date_retour_rar']=$this->dateDBToForm($val['date_retour_rar']);
1793                $val['date_envoi_controle_legalite']=$this->dateDBToForm($val['date_envoi_controle_legalite']);
1794                $val['date_retour_controle_legalite']=$this->dateDBToForm($val['date_retour_controle_legalite']);
1795                
1796                $this->setvalF($val);
1797    
1798                // Verification de la validite des donnees
1799                $this->verifier($this->val, $this->db, DEBUG);
1800                // Verification du verrou
1801                $this->testverrou();
1802                // Si les verifications precedentes sont correctes, on procede a
1803                // la modification, sinon on ne fait rien et on retourne une erreur
1804                if ($this->correct) {
1805                    // Execution du trigger 'before' specifique au MODE 'update'
1806                    $this->triggermodifier( $id, $this->db, $this->val, DEBUG);
1807                    $valF = array(
1808                            "om_final_instruction"=> ($status==1)?TRUE:FALSE,
1809                            "om_fichier_instruction"=>$uid,
1810                            "date_finalisation_courrier"=>date('Y-m-d'));
1811                    // Execution de la requête de modification des donnees de l'attribut
1812                    // valF de l'objet dans l'attribut table de l'objet
1813                    $res = $this->db->autoExecute(DB_PREFIXE.$this->table, $valF,
1814                        DB_AUTOQUERY_UPDATE, $this->getCle($id));
1815                     $this->addToLog("finaliser() : db->autoExecute(\"".DB_PREFIXE.$this->table."\", ".print_r($valF, true).", DB_AUTOQUERY_UPDATE, \"".$this->getCle($id)."\")", VERBOSE_MODE);
1816                    // Si une erreur survient
1817                    if (database::isError($res)) {
1818                        // Appel de la methode de recuperation des erreurs
1819                        $this->erreur_db($res->getDebugInfo(), $res->getMessage(), '');
1820                    } else {
1821                        // Log
1822                        $this->addToLog(_("Requete executee"), VERBOSE_MODE);
1823                        // Log
1824                        $message = _("Enregistrement")."&nbsp;".$id."&nbsp;";
1825                        $message .= _("de la table")."&nbsp;\"".$this->table."\"&nbsp;";
1826                        $message .= "[&nbsp;".$this->db->affectedRows()."&nbsp;";
1827                        $message .= _("enregistrement(s) mis a jour")."&nbsp;]";
1828                        $this->addToLog($message, VERBOSE_MODE);
1829                        // Mise en place du verrou pour ne pas finaliser plusieurs fois
1830                        // le meme document
1831                        $this->verrouille();
1832                        // Execution du trigger 'after' specifique au MODE 'update'
1833                        //$this->triggermodifierapres($id, $this->db, $val, DEBUG);
1834    
1835                        return $retour;
1836                    }
1837                } else {
1838                    // Message d'echec (saut d'une ligne supplementaire avant le
1839                    // message pour qu'il soit mis en evidence)
1840                    $this->addToLog(_("Finalisation non enregistree"));
1841                    return -1;
1842                }
1843            }
1844            // Si le document n'a pas été stocké
1845            else{
1846                return -1;
1847          }          }
1848        }
1849    
1850          $dossier_autorisation->modifier($valDossierAutorisation, $this->db, DEBUG);      /**
1851                 * Récupération du numéro de dossier d'instruction à ajouter aux métadonnées
1852          // Suppression du liens entre les lots et le DA       * @return string numéro de dossier d'instruction
1853          $valLot['dossier_autorisation'] = NULL;       */
1854          $this->db->autoExecute(DB_PREFIXE."lot", $valLot, DB_AUTOQUERY_UPDATE, "dossier_autorisation='".$IDdossier_autorisation."'");      protected function getDossier() {
1855                    if(empty($this->specificMetadata)) {
1856          // Liaison des lots du DI avec le DA              $this->getSpecificMetadata();
         $sqlLot = "SELECT lot FROM ".DB_PREFIXE."lien_dossier_lot WHERE dossier='".$this->valF['dossier']."'";  
         $res = $this->db->query($sqlLot);  
         $this->addToLog($sqlLot);  
         $this->f->isDatabaseError();  
         while($rowLot = $res->fetchRow(DB_FETCHMODE_ASSOC)) {  
             $valLot['dossier_autorisation'] = $IDdossier_autorisation;  
             $this->db->autoExecute(DB_PREFIXE."lot", $valLot, DB_AUTOQUERY_UPDATE, "lot=".$rowLot['lot']);  
1857          }          }
1858            return $this->specificMetadata->dossier;
1859      }      }
1860            /**
1861      // Récupération de l'identifiant du dossier d'autorisation lié au dossier d'instruction       * Récupération la version du dossier d'instruction à ajouter aux métadonnées
1862      function getDossierAutorisation($dossier_instruction){       * @return int Version
1863         */
1864        protected function getDossierVersion() {
1865            if(empty($this->specificMetadata)) {
1866                $this->getSpecificMetadata();
1867            }
1868            return $this->specificMetadata->version;
1869        }
1870        /**
1871         * Récupération du numéro de dossier d'autorisation à ajouter aux métadonnées
1872         * @return string numéro de dossier d'autorisation
1873         */
1874        protected function getNumDemandeAutor() {
1875            if(empty($this->specificMetadata)) {
1876                $this->getSpecificMetadata();
1877            }
1878            return $this->specificMetadata->dossier_autorisation;
1879        }
1880        /**
1881         * Récupération de la date de demande initiale du dossier à ajouter aux métadonnées
1882         * @return date de la demande initiale
1883         */
1884        protected function getAnneemoisDemandeAutor() {
1885            if(empty($this->specificMetadata)) {
1886                $this->getSpecificMetadata();
1887            }
1888            return $this->specificMetadata->date_demande_initiale;
1889        }
1890        /**
1891         * Récupération du type de dossier d'instruction à ajouter aux métadonnées
1892         * @return string type du dossier d'instruction
1893         */
1894        protected function getTypeInstruction() {
1895            if(empty($this->specificMetadata)) {
1896                $this->getSpecificMetadata();
1897            }
1898            return $this->specificMetadata->dossier_instruction_type;
1899        }
1900        /**
1901         * Récupération du statut du dossier d'autorisation à ajouter aux métadonnées
1902         * @return string avis
1903         */
1904        protected function getStatutAutorisation() {
1905            if(empty($this->specificMetadata)) {
1906                $this->getSpecificMetadata();
1907            }
1908            return $this->specificMetadata->statut;
1909        }
1910        /**
1911         * Récupération du type de dossier d'autorisation à ajouter aux métadonnées
1912         * @return string type du dossier d'autorisation
1913         */
1914        protected function getTypeAutorisation() {
1915            if(empty($this->specificMetadata)) {
1916                $this->getSpecificMetadata();
1917            }
1918            return $this->specificMetadata->dossier_autorisation_type;
1919        }
1920        /**
1921         * Récupération de la date d'ajout de document à ajouter aux métadonnées
1922         * @return date de l'évènement
1923         */
1924        protected function getDateEvenementDocument() {
1925            return date("Y-m-d");
1926        }
1927        /**
1928         * Récupération du groupe d'instruction à ajouter aux métadonnées
1929         * @return string Groupe d'instruction
1930         */
1931        protected function getGroupeInstruction() {
1932            if(empty($this->specificMetadata)) {
1933                $this->getSpecificMetadata();
1934            }
1935            return $this->specificMetadata->groupe_instruction;
1936        }
1937        /**
1938         * Récupération du libellé du type du document à ajouter aux métadonnées
1939         * @return string Groupe d'instruction
1940         */
1941        protected function getTitle() {
1942    
1943            // Récupère le champ événement
1944            if (isset($this->valF["evenement"]) AND $this->valF["evenement"] != "") {
1945                $evenement = $this->valF["evenement"];
1946            } else {
1947                $evenement = $this->getVal("evenement");
1948            }
1949    
1950            // Requête sql
1951            $sql = "SELECT libelle FROM ".DB_PREFIXE."evenement
1952                    WHERE evenement=".$evenement;
1953            $evenement_libelle = $this->db->getOne($sql);
1954            $this->addToLog("getTitle(): db->getOne(\"".$sql."\");", VERBOSE_MODE);
1955            if (database::isError($evenement_libelle)) {
1956                die();
1957            }
1958    
1959            // Retourne le libelle de l'événement
1960            return $evenement_libelle;
1961        }
1962    
1963        /**
1964         * Cette méthode permet de stocker en attribut toutes les métadonnées
1965         * nécessaire à l'ajout d'un document.
1966         */
1967        public function getSpecificMetadata() {
1968            if (isset($this->valF["dossier"]) AND $this->valF["dossier"] != "") {
1969                $dossier = $this->valF["dossier"];
1970            } else {
1971                $dossier = $this->getVal("dossier");
1972            }
1973            //Requête pour récupérer les informations essentiels sur le dossier d'instruction
1974            $sql = "SELECT dossier.dossier as dossier,
1975                            dossier_autorisation.dossier_autorisation as dossier_autorisation,
1976                            to_char(dossier.date_demande, 'YYYY/MM') as date_demande_initiale,
1977                            dossier_instruction_type.code as dossier_instruction_type,
1978                            etat_dossier_autorisation.libelle as statut,
1979                            dossier_autorisation_type.code as dossier_autorisation_type,
1980                            groupe.code as groupe_instruction
1981                    FROM ".DB_PREFIXE."dossier
1982                        LEFT JOIN ".DB_PREFIXE."dossier_instruction_type  
1983                            ON dossier.dossier_instruction_type = dossier_instruction_type.dossier_instruction_type
1984                        LEFT JOIN ".DB_PREFIXE."dossier_autorisation
1985                            ON dossier.dossier_autorisation = dossier_autorisation.dossier_autorisation
1986                        LEFT JOIN ".DB_PREFIXE."etat_dossier_autorisation
1987                            ON  dossier_autorisation.etat_dossier_autorisation = etat_dossier_autorisation.etat_dossier_autorisation
1988                        LEFT JOIN ".DB_PREFIXE."dossier_autorisation_type_detaille
1989                            ON dossier_autorisation.dossier_autorisation_type_detaille = dossier_autorisation_type_detaille.dossier_autorisation_type_detaille
1990                        LEFT JOIN ".DB_PREFIXE."dossier_autorisation_type
1991                            ON dossier_autorisation_type_detaille.dossier_autorisation_type = dossier_autorisation_type.dossier_autorisation_type
1992                        LEFT JOIN ".DB_PREFIXE."groupe
1993                            ON dossier_autorisation_type.groupe = groupe.groupe
1994                    WHERE dossier.dossier = '".$dossier."'";
1995            $res = $this->db->query($sql);
1996            $this->f->addToLog("getSpecificMetadata() : db->query(".$sql.")", VERBOSE_MODE);
1997            if ( database::isError($res)){
1998                die();
1999            }
2000                    
2001          $sql = "SELECT          //Le résultat est récupéré dans un objet
2002                      dossier_autorisation.dossier_autorisation          $row =& $res->fetchRow(DB_FETCHMODE_OBJECT);
2003                  FROM  
2004                      ".DB_PREFIXE."dossier_autorisation          //Si il y a un résultat
2005                  LEFT JOIN          if ($row !== null) {
2006                    
2007                //Génération du numéro de version
2008                $sql = "SELECT
2009                            count(*)
2010                    FROM
2011                      ".DB_PREFIXE."dossier                      ".DB_PREFIXE."dossier
2012                    LEFT JOIN
2013                        ".DB_PREFIXE."dossier_autorisation
2014                      ON                      ON
2015                          dossier_autorisation.dossier_autorisation = dossier.dossier_autorisation                          dossier_autorisation.dossier_autorisation = dossier.dossier_autorisation
2016                    LEFT JOIN
2017                        ".DB_PREFIXE."dossier_instruction_type
2018                        ON
2019                            dossier_instruction_type.dossier_instruction_type = dossier.dossier_instruction_type
2020                  WHERE                  WHERE
2021                      dossier.dossier = '".$dossier_instruction."'";                      dossier_autorisation.dossier_autorisation = '".$row->dossier_autorisation."'
2022                              AND
2023          $IDdossier_autorisation = $this->db->getOne($sql);                      dossier_instruction_type.code = '".$row->dossier_instruction_type."'";
2024          $this->addToLog("getDossierAutorisation(): db->getone(\"".$sql."\")", VERBOSE_MODE);              $row->version = $this->db->getOne($sql);
2025          database::isError($IDdossier_autorisation);              $this->f->addToLog("getSpecificMetadata(): db->getOne(\"".$sql."\")", VERBOSE_MODE);
2026                if ( database::isError($row->version)){
2027                    $this->f->addToError("", $row->version, $row->version);
2028                    return false;
2029                }
2030                
2031                //Formatage du numéro de version
2032                $row->version = str_pad($row->version, 2, "0", STR_PAD_LEFT);
2033    
2034                //Alors on créé l'objet dossier_instruction
2035                $this->specificMetadata = $row;
2036    
2037            }
2038        }
2039        
2040        /**
2041         * Retourne le statut du dossier d'instruction
2042         * @param string $idx Identifiant du dossier d'instruction
2043         * @return string Le statut du dossier d'instruction
2044         */
2045        function getStatutAutorisationDossier($idx){
2046            
2047            $statut = '';
2048            
2049            //Si l'identifiant du dossier d'instruction fourni est correct
2050            if ( $idx != '' ){
2051                
2052                //On récupère le statut de l'état du dossier à partir de l'identifiant du
2053                //dossier
2054                $sql = "SELECT etat.statut
2055                    FROM ".DB_PREFIXE."dossier
2056                    LEFT JOIN
2057                        ".DB_PREFIXE."etat
2058                        ON
2059                            dossier.etat = etat.etat
2060                    WHERE dossier ='".$idx."'";
2061                $statut = $this->db->getOne($sql);
2062                $this->f->addToLog("getStatutAutorisationDossier() : db->getOne(\"".$sql."\")", VERBOSE_MODE);
2063                if ( database::isError($statut)){
2064                    die();
2065                }
2066            }
2067            return $statut;
2068        }
2069    
2070        /**
2071         * Récupère les données du dossier
2072         * @return array
2073         */
2074        function get_dossier_actual() {
2075    
2076            // Initialisation de la valeur de retour
2077            $return = array();
2078    
2079            // Récupération de toutes les valeurs du dossier d'instruction en cours
2080            $sql = "SELECT * FROM ".DB_PREFIXE."dossier
2081            WHERE dossier='".$this->valF['dossier']."'";
2082            $res = $this->db->query($sql);
2083            $this->addToLog("get_dossier_actual(): db->query(\"".$sql."\");", VERBOSE_MODE);
2084            $this->f->isDatabaseError($res);
2085    
2086            //
2087            while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
2088    
2089                // Récupération de la valeur actuelle du délai, de l'accord tacite,
2090                // de l'état et de l'avis du dossier d'instruction
2091                $return['archive_delai']=$row['delai'];
2092                $return['archive_accord_tacite']=$row['accord_tacite'];
2093                $return['archive_etat']=$row['etat'];
2094                $return['archive_avis']=$row['avis_decision'];
2095                // Récupération de la valeur actuelle des 9 dates du dossier
2096                // d'instruction
2097                $return['archive_date_complet']=$row['date_complet'];
2098                $return['archive_date_dernier_depot']=$row['date_dernier_depot'];
2099                $return['archive_date_rejet']= $row['date_rejet'];
2100                $return['archive_date_limite']= $row['date_limite'];
2101                $return['archive_date_notification_delai']= $row['date_notification_delai'];
2102                $return['archive_date_decision']= $row['date_decision'];
2103                $return['archive_date_validite']= $row['date_validite'];
2104                $return['archive_date_achevement']= $row['date_achevement'];
2105                $return['archive_date_chantier']= $row['date_chantier'];
2106                $return['archive_date_conformite']= $row['date_conformite'];  
2107                $return['archive_incompletude']= $row['incompletude'];  
2108                $return['archive_evenement_suivant_tacite']= $row['evenement_suivant_tacite'];  
2109                $return['archive_evenement_suivant_tacite_incompletude']= $row['evenement_suivant_tacite_incompletude'];  
2110                $return['archive_etat_pendant_incompletude']= $row['etat_pendant_incompletude'];  
2111                $return['archive_date_limite_incompletude']= $row['date_limite_incompletude'];  
2112                $return['archive_delai_incompletude']= $row['delai_incompletude'];  
2113                $return['archive_autorite_competente']= $row['autorite_competente'];  
2114                $return['duree_validite']= $row['duree_validite'];  
2115            }
2116    
2117            // Retour de la fonction
2118            return $return;
2119    
2120        }
2121    
2122        /**
2123         * Permet de vérifier qu'un événement est verrouillable
2124         * @param  integer $idx     Identifiant de l'instruction
2125         * @return boolean          
2126         */
2127        function checkEvenementNonVerrouillable($idx) {
2128    
2129            // Initialisation du résultat
2130            $non_verrouillable = false;
2131    
2132            // Si la condition n'est pas vide
2133            if ($idx != "") {
2134    
2135                // Requête SQL
2136                $sql = "SELECT evenement.non_verrouillable
2137                        FROM ".DB_PREFIXE."evenement
2138                        LEFT JOIN ".DB_PREFIXE."instruction
2139                            ON instruction.evenement = evenement.evenement
2140                        WHERE instruction.instruction = $idx";
2141                $this->f->addToLog("checkEvenementNonVerrouillable() : db->getOne(\"".$sql."\")", VERBOSE_MODE);
2142                $res = $this->db->getOne($sql);
2143                $this->f->isDatabaseError($res);
2144    
2145                // Si le retour de la requête est true
2146                if ($res == 't') {
2147                    //
2148                    $non_verrouillable = true;
2149                }
2150            }
2151    
2152            // Retourne résultat
2153            return $non_verrouillable;
2154        }
2155        
2156        /**
2157         * Mise à jour des champs archive_*
2158         * @param mixed $row La ligne de données
2159         */
2160        public function updateArchiveData($row){
2161                    
2162          return $IDdossier_autorisation;          // Récupération de la valeur actuelle du délai, de l'accord tacite,
2163            // de l'état et de l'avis du dossier d'instruction
2164            $this->valF['archive_delai']=$row['delai'];
2165            $this->valF['archive_accord_tacite']=$row['accord_tacite'];
2166            $this->valF['archive_etat']=$row['etat'];
2167            $this->valF['archive_avis']=$row['avis_decision'];
2168            // Récupération de la valeur actuelle des 9 dates du dossier
2169            // d'instruction
2170            if ($row['date_complet'] != '') {
2171                $this->valF['archive_date_complet']=$row['date_complet'];
2172            }
2173            if ($row['date_dernier_depot'] != '') {
2174                $this->valF['archive_date_dernier_depot']=$row['date_dernier_depot'];
2175            }
2176            if ($row['date_rejet']!='') {
2177                $this->valF['archive_date_rejet']= $row['date_rejet'];
2178            }
2179            if ($row['date_limite']!='') {
2180                $this->valF['archive_date_limite']= $row['date_limite'];
2181            }
2182            if ($row['date_notification_delai']!='') {
2183                $this->valF['archive_date_notification_delai']= $row['date_notification_delai'];
2184            }
2185            if ($row['date_decision']!='') {
2186                $this->valF['archive_date_decision']= $row['date_decision'];
2187            }
2188            if ($row['date_validite']!='') {
2189                $this->valF['archive_date_validite']= $row['date_validite'];
2190            }
2191            if ($row['date_achevement']!='') {
2192                $this->valF['archive_date_achevement']= $row['date_achevement'];
2193            }
2194            if ($row['date_chantier']!='') {
2195                $this->valF['archive_date_chantier']= $row['date_chantier'];
2196            }
2197            if ($row['date_conformite']!='') {
2198                $this->valF['archive_date_conformite']= $row['date_conformite'];  
2199            }
2200            if ($row['incompletude']!='') {
2201                $this->valF['archive_incompletude']= $row['incompletude'];  
2202            }
2203            if ($row['evenement_suivant_tacite']!='') {
2204                $this->valF['archive_evenement_suivant_tacite']= $row['evenement_suivant_tacite'];  
2205            }
2206            if ($row['evenement_suivant_tacite_incompletude']!='') {
2207                $this->valF['archive_evenement_suivant_tacite_incompletude']= $row['evenement_suivant_tacite_incompletude'];  
2208            }
2209            if ($row['etat_pendant_incompletude']!='') {
2210                $this->valF['archive_etat_pendant_incompletude']= $row['etat_pendant_incompletude'];  
2211            }
2212            if ($row['date_limite_incompletude']!='') {
2213                $this->valF['archive_date_limite_incompletude']= $row['date_limite_incompletude'];  
2214            }
2215            if ($row['delai_incompletude']!='') {
2216                $this->valF['archive_delai_incompletude']= $row['delai_incompletude'];  
2217            }
2218            if ($row['autorite_competente']!='') {
2219                $this->valF['archive_autorite_competente']= $row['autorite_competente'];  
2220            }
2221            if ($row['duree_validite']!='') {
2222                $this->valF['duree_validite']= $row['duree_validite'];  
2223            }
2224      }      }
2225  }// fin classe  }// fin classe
2226  ?>  ?>
Legend:
Removed from v.1571  
changed lines
  Added in v.2771
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26