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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 5295 - (show annotations)
Tue Nov 29 09:28:27 2016 UTC (8 years, 2 months ago) by softime
File size: 220706 byte(s)
* Merge de la branche 3.34.x.
* Retour développement eb 3.34.3 après release 3.34.2.

1 <?php
2 /**
3 * specific :
4 * - cle secondaire
5 * destruction autorisée que pour le dernier evenement
6 * [delete the last event ]
7 * - variable globale [global variables]
8 * var $retourformulaire;
9 * var $idxformulaire;
10 * - modification des données dans dossier trigger avant
11 * [modify dossier data with trigger function]
12 * - function mois_date : pour ajouter des mois a une date
13 * [add months (delay) and calculation final date]
14 * - voir script_lang.js : bible ...
15 *
16 * @package openfoncier
17 * @version SVN : $Id$
18 */
19
20 //
21 require_once "../gen/obj/instruction.class.php";
22
23 //
24 class instruction extends instruction_gen {
25
26 // Champs contenant les UID des fichiers
27 var $abstract_type = array(
28 "om_fichier_instruction" => "file",
29 );
30
31 var $retourformulaire; // specific
32 var $idxformulaire; // specific
33 var $valEvenement;
34 var $restriction_valid = null;
35 // Tableau contenant une partie des métadonnées arrêtés
36 var $metadonneesArrete;
37
38 /**
39 * Instance de la classe dossier
40 *
41 * @var mixed
42 */
43 var $inst_dossier = null;
44
45 /**
46 * Instance de la classe instructeur
47 *
48 * @var mixed
49 */
50 var $inst_instructeur = null;
51
52 /**
53 * Instance de la classe om_utilisateur
54 *
55 * @var mixed
56 */
57 var $inst_om_utilisateur = null;
58
59 var $metadata = array(
60 "om_fichier_instruction" => array(
61 "dossier" => "getDossier",
62 "dossier_version" => "getDossierVersion",
63 "numDemandeAutor" => "getNumDemandeAutor",
64 "anneemoisDemandeAutor" => "getAnneemoisDemandeAutor",
65 "typeInstruction" => "getTypeInstruction",
66 "statutAutorisation" => "getStatutAutorisation",
67 "typeAutorisation" => "getTypeAutorisation",
68 "dateEvenementDocument" => "getDateEvenementDocument",
69 "groupeInstruction" => 'getGroupeInstruction',
70 "title" => 'getTitle',
71 ),
72 "arrete" => array(
73 "numArrete" => "getNumArrete",
74 "ReglementaireArrete" => "getReglementaireArrete",
75 "NotificationArrete" => "getNotificationArrete",
76 "dateNotificationArrete" => "getDateNotificationArrete",
77 "controleLegalite" => "getControleLegalite",
78 "dateSignature" => "getDateSignature",
79 "nomSignataire" => "getNomSignataire",
80 "qualiteSignataire" => "getQualiteSignataire",
81 "ap_numRue" => "getAp_numRue",
82 "ap_nomDeLaVoie" => "getAp_nomDeLaVoie",
83 "ap_codePostal" => "getAp_codePostal",
84 "ap_ville" => "getAp_ville",
85 "activite" => "getActivite",
86 "dateControleLegalite" => "getDateControleLegalite",
87 ),
88 );
89 /** @var boolean Les nouvelles actions sont activées sur cet objet */
90 var $activate_class_action;
91
92 function __construct($id, &$db, $debug) {
93 //On active les nouvelles actions
94 $this->activate_class_action = true;
95 $this->constructeur($id, $db, $debug);
96 }
97
98 // {{{ Gestion de la confidentialité des données spécifiques
99
100 /**
101 * Définition des actions disponibles sur la classe.
102 *
103 * @return void
104 */
105 function init_class_actions() {
106
107 parent::init_class_actions();
108
109 // ACTION - 000 - ajouter
110 // Modifie la condition d'affichage du bouton ajouter
111 $this->class_actions[0]["condition"] = array("is_addable");
112
113 // ACTION - 001 - modifier
114 // Modifie la condition et le libellé du bouton modifier
115 $this->class_actions[1]["condition"] = array("is_editable", "is_finalizable_without_bypass");
116 $this->class_actions[1]["portlet"]["libelle"] = _("Modifier");
117
118 // ACTION - 002 - supprimer
119 // Modifie la condition et le libellé du bouton supprimer
120 $this->class_actions[2]["condition"] = array("is_deletable", "is_finalizable_without_bypass");
121 $this->class_actions[2]["portlet"]["libelle"] = _("Supprimer");
122
123 // ACTION - 100 - finaliser
124 // Finalise l'enregistrement
125 $this->class_actions[100] = array(
126 "identifier" => "finaliser",
127 "portlet" => array(
128 "type" => "action-direct",
129 "libelle" => _("Finaliser le document"),
130 "order" => 110,
131 "class" => "finalise",
132 ),
133 "view" => "formulaire",
134 "method" => "finalize",
135 "button" => "finaliser",
136 "permission_suffix" => "finaliser",
137 "condition" => array("is_finalizable", "is_finalizable_without_bypass", "has_an_edition"),
138 );
139
140 // ACTION - 110 - definaliser
141 // Finalise l'enregistrement
142 $this->class_actions[110] = array(
143 "identifier" => "definaliser",
144 "portlet" => array(
145 "type" => "action-direct",
146 "libelle" => _("Reprendre la redaction du document"),
147 "order" => 110,
148 "class" => "definalise",
149 ),
150 "view" => "formulaire",
151 "method" => "unfinalize",
152 "button" => "definaliser",
153 "permission_suffix" => "definaliser",
154 "condition" => array("is_unfinalizable", "is_unfinalizable_without_bypass"),
155 );
156
157 // ACTION - 120 - edition
158 // Affiche l'édition
159 $this->class_actions[120] = array(
160 "identifier" => "edition",
161 "portlet" => array(
162 "type" => "action-blank",
163 "libelle" => _("Edition"),
164 "order" => 100,
165 "class" => "pdf-16",
166 ),
167 "view" => "view_edition",
168 "condition" => "has_an_edition",
169 "permission_suffix" => "om_fichier_instruction_telecharger",
170 );
171
172 // ACTION - 125 - modifier_suivi
173 // Suivi des dates
174 $this->class_actions[125] = array(
175 "identifier" => "modifier_suivi",
176 "portlet" => array(
177 "type" => "action-self",
178 "libelle" => _("Suivi des dates"),
179 "order" => 125,
180 "class" => "suivi-dates-16",
181 ),
182 "crud" => "update",
183 "condition" => "can_monitoring_dates",
184 "permission_suffix" => "modification_dates",
185 );
186
187 // ACTION - 130 - bible
188 // Affiche la bible
189 $this->class_actions[130] = array(
190 "identifier" => "bible",
191 "view" => "view_bible",
192 "permission_suffix" => "modifier",
193 );
194
195 // ACTION - 140 - bible_auto
196 // Active la bible automatique
197 $this->class_actions[140] = array(
198 "identifier" => "bible_auto",
199 "view" => "view_bible_auto",
200 "permission_suffix" => "modifier",
201 );
202
203 // ACTION - 150 - suivi_bordereaux
204 // Imprimer un bordereau d'envoi
205 $this->class_actions[150] = array(
206 "identifier" => "suivi_bordereaux",
207 "view" => "view_suivi_bordereaux",
208 "permission_suffix" => "consulter",
209 );
210
211 // ACTION - 160 - suivi_envoi_lettre_rar
212 // Imprimer un bordereau d'envoi
213 $this->class_actions[160] = array(
214 "identifier" => "suivi_envoi_lettre_rar",
215 "view" => "view_suivi_envoi_lettre_rar",
216 "permission_suffix" => "consulter",
217 );
218
219 // ACTION - 170 - suivi_mise_a_jour_des_dates
220 // Mettre à jour les dates de l'instruction
221 $this->class_actions[170] = array(
222 "identifier" => "suivi_mise_a_jour_des_dates",
223 "view" => "view_suivi_mise_a_jour_des_dates",
224 "permission_suffix" => "consulter",
225 );
226
227 // ACTION - 180 - pdf_lettre_rar
228 // Génère PDF sur bordereaux de lettres RAR
229 $this->class_actions[180] = array(
230 "identifier" => "pdf_lettre_rar",
231 "view" => "view_pdf_lettre_rar",
232 "permission_suffix" => "consulter",
233 );
234
235 // ACTION - 190 - bordereau_envoi_maire
236 // Formulaire pour générer le bordereau d'envoi au maire
237 // Met à jour la date d'envoi à signature du maire
238 $this->class_actions[190] = array(
239 "identifier" => "bordereau_envoi_maire",
240 "view" => "view_bordereau_envoi_maire",
241 "permission_suffix" => "bordereau_envoi_maire",
242 );
243
244 // ACTION - 200 - generate_bordereau_envoi_maire
245 // Génère PDF bordereau d'envoi au maire
246 $this->class_actions[200] = array(
247 "identifier" => "generate_bordereau_envoi_maire",
248 "view" => "view_generate_bordereau_envoi_maire",
249 "permission_suffix" => "bordereau_envoi_maire",
250 );
251
252 // ACTION - 210 - notifier_commune
253 // Notifie la commune par mail d'un évément d'instruction finalisé
254 $this->class_actions[210] = array(
255 "identifier" => "notifier_commune",
256 "portlet" => array(
257 "type" => "action-direct-with-confirmation",
258 "libelle" => _("Notifier la commune par courriel"),
259 "order" => 210,
260 "class" => "notifier_commune-16",
261 ),
262 "view" => "formulaire",
263 "method" => "notifier_commune",
264 "permission_suffix" => "notifier_commune",
265 "condition" => "is_notifiable",
266 );
267
268 // ACTION - 220 - generate_suivi_bordereaux
269 // GénÚre PDF bordereaux
270 $this->class_actions[220] = array(
271 "identifier" => "generate_suivi_bordereaux",
272 "view" => "view_generate_suivi_bordereaux",
273 "permission_suffix" => "consulter",
274 );
275 }
276
277 /**
278 * Cette variable permet de stocker le résultat de la méthode
279 * getDivisionFromDossier() afin de ne pas effectuer le recalcul à chacun de
280 * ces appels.
281 * @var string Code de la division du dossier en cours
282 */
283 var $_division_from_dossier = NULL;
284
285 /**
286 * Cette méthode permet de récupérer le code de division correspondant
287 * au dossier sur lequel on se trouve.
288 *
289 * @return string Code de la division du dossier en cours
290 */
291 function getDivisionFromDossier() {
292
293 // Cette méthode peut être appelée plusieurs fois lors d'une requête.
294 // Pour éviter de refaire le traitement de recherche de la division
295 // alors on vérifie si nous ne l'avons pas déjà calculé.
296 if ($this->_division_from_dossier != NULL) {
297 // Logger
298 $this->addToLog("getDivisionFromDossier(): retour de la valeur déjà calculée - '".$this->_division_from_dossier."'", EXTRA_VERBOSE_MODE);
299 // On retourne la valeur déjà calculée
300 return $this->_division_from_dossier;
301 }
302
303 // Par défaut, on définit la valeur du dossier à NULL
304 $dossier = NULL;
305 // Test sur le mode et le contexte du formulaire
306 if ($this->getParameter("maj") == 0
307 && ($this->getParameter("retourformulaire") == "dossier"
308 || $this->getParameter("retourformulaire") == "dossier_instruction"
309 || $this->getParameter("retourformulaire") == "dossier_instruction_mes_encours"
310 || $this->getParameter("retourformulaire") == "dossier_instruction_tous_encours"
311 || $this->getParameter("retourformulaire") == "dossier_instruction_mes_clotures"
312 || $this->getParameter("retourformulaire") == "dossier_instruction_tous_clotures")) {
313 // Si on se trouve en mode AJOUT (seul mode où l'enregistrement
314 // n'existe pas en base de données) ET que nous nous trouvons
315 // dans le contexte d'un dossier d'instruction alors on récupère
316 // le numéro de dossier depuis le paramètre 'idxformulaire'
317 $dossier = $this->getParameter("idxformulaire");
318 } else {
319 // Sinon on récupère le numéro de dossier dans le champs dossier de
320 // l'enregistrement (en base de données)
321 $dossier = $this->getVal("dossier");
322 }
323
324 // On appelle la méthode de la classe utils qui renvoi le code de la
325 // division d'un dossier, on la stocke pour ne pas refaire le calcul au
326 // prochain appel de cette méthode
327 $this->_division_from_dossier = $this->f->getDivisionFromDossier($dossier);
328 // Logger
329 $this->addToLog("getDivisionFromDossier(): retour de la valeur nouvellement calculée - '".$this->_division_from_dossier."'", EXTRA_VERBOSE_MODE);
330 // On retourne la valeur retournée
331 return $this->_division_from_dossier;
332
333 }
334
335 /**
336 * Cette méthode permet de récupérer le dossier d'autorisation d'un dossier
337 */
338 function getNumDemandeAutorFromDossier($id) {
339 //
340 if (!isset($id)) {
341 return NULL;
342 }
343 //
344 $sql = "select dossier_autorisation from ".DB_PREFIXE."dossier ";
345 $sql .= " where dossier='".$id."'";
346 //
347 $dossier_autorisation = $this->db->getOne($sql);
348 $this->addToLog("getNumDemandeAutorFromDossier(): db->getone(\"".$sql."\")", VERBOSE_MODE);
349 database::isError($dossier_autorisation);
350 //
351 return $dossier_autorisation;
352 }
353
354 // }}}
355
356 function setType(&$form, $maj) {
357 //
358 parent::setType($form, $maj);
359 // On cache tous les champs
360 // XXX
361 $form->setType('complement5_om_html', 'hidden');
362 $form->setType('bible5', 'hidden');
363 $form->setType('complement6_om_html', 'hidden');
364 $form->setType('bible6', 'hidden');
365 $form->setType('complement7_om_html', 'hidden');
366 $form->setType('bible7', 'hidden');
367 $form->setType('complement8_om_html', 'hidden');
368 $form->setType('bible8', 'hidden');
369 $form->setType('complement9_om_html', 'hidden');
370 $form->setType('bible9', 'hidden');
371 $form->setType('complement10_om_html', 'hidden');
372 $form->setType('bible10', 'hidden');
373 $form->setType('complement11_om_html', 'hidden');
374 $form->setType('bible11', 'hidden');
375 $form->setType('complement12_om_html', 'hidden');
376 $form->setType('bible12', 'hidden');
377 $form->setType('complement13_om_html', 'hidden');
378 $form->setType('bible13', 'hidden');
379 $form->setType('complement14_om_html', 'hidden');
380 $form->setType('bible14', 'hidden');
381 $form->setType('complement15_om_html', 'hidden');
382 $form->setType('bible15', 'hidden');
383 //
384 $form->setType('delai', 'hidden');
385 $form->setType('etat', 'hidden');
386 $form->setType('accord_tacite', 'hidden');
387 $form->setType('action', 'hidden');
388 $form->setType('delai_notification', 'hidden');
389 $form->setType('avis_decision', 'hidden');
390 $form->setType('autorite_competente', 'hidden');
391 //
392 $form->setType('archive_delai', 'hidden');
393 $form->setType('archive_etat', 'hidden');
394 $form->setType('archive_accord_tacite', 'hidden');
395 $form->setType('archive_avis', 'hidden');
396 $form->setType('archive_date_complet', 'hiddendate');
397 $form->setType('archive_date_dernier_depot', 'hiddendate');
398 $form->setType('archive_date_rejet', 'hiddendate');
399 $form->setType('archive_date_limite', 'hiddendate');
400 $form->setType('archive_date_notification_delai', 'hiddendate');
401 $form->setType('archive_date_decision', 'hiddendate');
402 $form->setType('archive_date_validite', 'hiddendate');
403 $form->setType('archive_date_achevement', 'hiddendate');
404 $form->setType('archive_date_conformite', 'hiddendate');
405 $form->setType('archive_date_chantier', 'hiddendate');
406 $form->setType('archive_autorite_competente','hidden');
407 $form->setType('date_depot','hidden');
408 //
409 $form->setType('numero_arrete', 'hidden');
410 //
411 $form->setType('code_barres', 'hidden');
412
413 //
414 $form->setType('archive_incompletude','hidden');
415 $form->setType('archive_incomplet_notifie','hidden');
416 $form->setType('archive_evenement_suivant_tacite','hidden');
417 $form->setType('archive_evenement_suivant_tacite_incompletude','hidden');
418 $form->setType('archive_etat_pendant_incompletude','hidden');
419 $form->setType('archive_date_limite_incompletude','hiddendate');
420 $form->setType('archive_delai_incompletude','hidden');
421
422 //
423 $form->setType('duree_validite','hidden');
424 $form->setType('duree_validite_parametrage','hidden');
425
426 //
427 $form->setType('created_by_commune','hidden');
428 //
429 // gestion du champ "finalisé par"
430 if ($this->getVal("om_final_instruction") == 't') {
431 $form->setType('om_final_instruction_utilisateur', 'static');
432 } else {
433 $form->setType('om_final_instruction_utilisateur', 'hidden');
434 }
435 //
436 if ($maj < 2 || $maj == 125) { //ajouter, modifier et suivi des dates
437 $form->setType('destinataire', 'hidden');
438 $form->setType('lettretype', 'hiddenstatic');
439 $form->setType('complement_om_html', 'html');
440 $form->setType('complement2_om_html', 'html');
441 $form->setType('complement3_om_html', 'html');
442 $form->setType('complement4_om_html', 'html');
443 $form->setType('bible_auto', 'httpclick');
444 $form->setType('bible', 'httpclick');
445 $form->setType('bible2', 'httpclick');
446 $form->setType('bible3', 'httpclick');
447 $form->setType('bible4', 'httpclick');
448 $form->setType('dossier', 'hidden');
449 $form->setType('libelle', 'hiddenstatic');
450 $form->setType('signataire_arrete','select');
451 $form->setType('date_envoi_signature','datedisabled');
452 $form->setType('date_retour_signature','datedisabled');
453 $form->setType('date_envoi_rar','datedisabled');
454 $form->setType('date_retour_rar','datedisabled');
455 $form->setType('date_envoi_controle_legalite','datedisabled');
456 $form->setType('date_retour_controle_legalite','datedisabled');
457 $form->setType('date_finalisation_courrier','datedisabled');
458
459 if($maj==0){ // ajouter
460 $form->setType('instruction', 'hidden');
461 $form->setType('lettretype', 'hidden');
462 $form->setType('evenement', 'select');
463 $form->setType('date_evenement', 'date2');
464 }else{ // modifier et suivi des dates
465 $form->setType('instruction', 'hiddenstatic');
466 $form->setType('evenement', 'selecthiddenstatic');
467 //$form->setType('date_evenement', 'hiddenstaticdate');
468 $form->setType('date_evenement', 'date2');
469 // necessaire pour calcul de date en modification
470 //$form->setType('delai', 'hiddenstatic');
471 // les administrateurs technique et fonctionnel peuvent
472 // modifier tous les champs de date
473 // si l'instruction a déjà été finalisée au moins une fois
474 if ($this->f->isAccredited(array("instruction", "instruction_modification_dates"), "OR")
475 && $this->getVal("date_finalisation_courrier") != '') {
476 $form->setType('date_envoi_signature', 'date');
477 $form->setType('date_retour_signature', 'date');
478 $form->setType('date_envoi_rar', 'date');
479 $form->setType('date_retour_rar', 'date');
480 $form->setType('date_envoi_controle_legalite', 'date');
481 $form->setType('date_retour_controle_legalite', 'date');
482 $form->setType('date_finalisation_courrier', 'date');
483 // suivi des dates
484 if ($maj == 125) {
485 $form->setType('date_evenement', 'hiddenstaticdate');
486 $form->setType('complement_om_html', 'hiddenstatic');
487 $form->setType('complement2_om_html', 'hiddenstatic');
488 $form->setType('complement3_om_html', 'hiddenstatic');
489 $form->setType('complement4_om_html', 'hiddenstatic');
490 $form->setType('bible_auto', 'hidden');
491 $form->setType('bible', 'hidden');
492 $form->setType('bible2', 'hidden');
493 $form->setType('bible3', 'hidden');
494 $form->setType('bible4', 'hidden');
495 $form->setType('signataire_arrete','selecthiddenstatic');
496 $form->setType('om_final_instruction_utilisateur', 'hiddenstatic');
497 }
498 }
499 }
500 } elseif($maj==2){
501 $form->setType('dossier', 'hidden');
502 $form->setType('bible_auto', 'hidden');
503 $form->setType('bible', 'hidden');
504 $form->setType('bible2', 'hidden');
505 $form->setType('bible3', 'hidden');
506 $form->setType('bible4', 'hidden');
507 }else {
508 $form->setType('destinataire', 'hidden');
509 $form->setType('dossier', 'hidden');
510 $form->setType('bible_auto', 'hidden');
511 $form->setType('bible', 'hidden');
512 $form->setType('bible2', 'hidden');
513 $form->setType('bible3', 'hidden');
514 $form->setType('bible4', 'hidden');
515 }
516
517 //Cache les champs pour la finalisation
518 $form->setType('om_fichier_instruction', 'hidden');
519 $form->setType('om_final_instruction', 'hidden');
520 // Cache le document arrêté
521 $form->setType('document_numerise', 'hidden');
522
523 //Masquer les champs date_envoi_controle_legalite et
524 //date_retour_controle_legalite si ce n'est pas un arrêté et si ce n'est
525 //pas un utilisateur ayant le droit spécifique
526 if ( !is_numeric($this->getVal("avis_decision"))&&
527 !$this->f->isAccredited(array("instruction", "instruction_modification_dates"), "OR")){
528
529 $form->setType("date_envoi_controle_legalite", "hiddendate");
530 $form->setType("date_retour_controle_legalite", "hiddendate");
531 }
532
533 // Pour les actions finalize, unfinalize et notifier_commune
534 if($maj == 100 || $maj == 110 || $maj == 210) {
535 //
536 foreach ($this->champs as $value) {
537 // Cache tous les champs
538 $form->setType($value, 'hidden');
539 }
540 }
541 }
542
543 function setSelect(&$form, $maj,&$db,$debug) {
544 /**
545 * On ne surcharge pas la méthode parent car une requête sur la table
546 * dossier est mauvaise pour les performances, car la requête qui
547 * concerne evenement est plus complexe que celle générée et car les
548 * champs action, avis_decision et etat ne sont pas utilisés comme des
549 * select
550 */
551 if(file_exists ("../sql/".OM_DB_PHPTYPE."/".$this->table.".form.inc.php"))
552 include ("../sql/".OM_DB_PHPTYPE."/".$this->table.".form.inc.php");
553 elseif(file_exists ("../sql/".OM_DB_PHPTYPE."/".$this->table.".form.inc"))
554 include ("../sql/".OM_DB_PHPTYPE."/".$this->table.".form.inc");
555
556 //// action
557 //$this->init_select($form, $db, $maj, $debug, "action",
558 // $sql_action, $sql_action_by_id, false);
559
560 //// avis_decision
561 //$this->init_select($form, $db, $maj, $debug, "avis_decision",
562 // $sql_avis_decision, $sql_avis_decision_by_id, false);
563
564 //// dossier
565 //$this->init_select($form, $db, $maj, $debug, "dossier",
566 // $sql_dossier, $sql_dossier_by_id, false);
567
568 //// etat
569 //$this->init_select($form, $db, $maj, $debug, "etat",
570 // $sql_etat, $sql_etat_by_id, false);
571
572 //// evenement
573 //$this->init_select($form, $db, $maj, $debug, "evenement",
574 // $sql_evenement, $sql_evenement_by_id, false);
575
576 // signataire_arrete
577 // si contexte DI
578 if ($this->getParameter("retourformulaire") == "dossier"
579 || $this->getParameter("retourformulaire") == "dossier_instruction"
580 || $this->getParameter("retourformulaire") == "dossier_instruction_mes_encours"
581 || $this->getParameter("retourformulaire") == "dossier_instruction_tous_encours"
582 || $this->getParameter("retourformulaire") == "dossier_instruction_mes_clotures"
583 || $this->getParameter("retourformulaire") == "dossier_instruction_tous_clotures") {
584 // on recupère les signataires de la multicollectivité et de celle du DI
585 require_once "../obj/dossier_instruction.class.php";
586 $di = new dossier_instruction($this->getParameter('idxformulaire'), $db, $debug);
587 $sql_signataire_arrete_by_di = str_replace('<collectivite_di>', $di->getVal("om_collectivite"), $sql_signataire_arrete_by_di);
588 $this->init_select($form, $db, $maj, $debug, "signataire_arrete",
589 $sql_signataire_arrete_by_di, $sql_signataire_arrete_by_id, true);
590 } else {
591 $this->init_select($form, $db, $maj, $debug, "signataire_arrete",
592 $sql_signataire_arrete, $sql_signataire_arrete_by_id, true);
593 }
594
595 /**
596 * Gestion du filtre sur les événements de workflow disponibles
597 * On récupère ici en fonction de l'état du dossier d'instruction en
598 * cours et du type du dossier d'instruction en cours la liste
599 * événements disponibles.
600 */
601 if ($maj == 0) {
602 // Récupération des événements par une jointure entre la table dossier
603 // et la table transition et la table evenement et la table
604 // lien_dossier_instruction_type_evenement en fonction de l'identifiant
605 // du dossier d'instruction en cours
606 $sql = "SELECT
607 evenement.evenement,
608 evenement.libelle as lib
609 FROM ".DB_PREFIXE."dossier
610 INNER JOIN ".DB_PREFIXE."lien_dossier_instruction_type_evenement
611 ON dossier.dossier_instruction_type=lien_dossier_instruction_type_evenement.dossier_instruction_type
612 INNER JOIN ".DB_PREFIXE."evenement
613 ON evenement.evenement=lien_dossier_instruction_type_evenement.evenement
614 INNER JOIN ".DB_PREFIXE."transition
615 ON evenement.evenement = transition.evenement
616 AND dossier.etat=transition.etat
617 WHERE dossier.dossier='".$this->idxformulaire."' ";
618
619 // Si changement de décision par instructeur commune
620 if($this->f->isUserInstructeur() === true
621 && $this->f->getDivisionFromDossier($this->idxformulaire) != $_SESSION["division"]
622 && $this->f->isInstrCanChangeDecision($this->idxformulaire) === true) {
623 $sql .= "AND evenement.type IN ('arrete', 'changement_decision') ";
624 }
625 $sql .= "ORDER BY evenement.libelle, evenement.action";
626 $res = $db->query($sql);
627 $this->addToLog("setSelect(): db->query(\"".$sql."\");", VERBOSE_MODE);
628 if (database::isError($res)) {
629 die($res->getMessage());
630 }
631 // Remplissage du tableau du select
632 $contenu = array(
633 0 => array("",),
634 1 => array(_('choisir')." "._('evenement'),)
635 );
636 while ($row=& $res->fetchRow()) {
637 $contenu[0][] = $row[0];
638 $contenu[1][] = $row[1];
639 }
640 $form->setSelect("evenement", $contenu);
641 } else {
642 $sql = "SELECT
643 evenement.libelle as lib
644 FROM ".DB_PREFIXE."evenement
645 WHERE evenement.evenement=".$this->getVal("evenement")."";
646 $res = $db->getone($sql);
647 $this->addToLog("setSelect(): db->getone(\"".$sql."\");", VERBOSE_MODE);
648 if (database::isError($res)) {
649 die($res->getMessage());
650 }
651 //
652 $contenu = array(
653 0 => array($this->getVal("evenement"),),
654 1 => array($res,)
655 );
656 $form->setSelect("evenement", $contenu);
657 }
658
659 /**
660 * Gesion des liens vers la bible
661 */
662 // lien bible_auto
663 $contenu = array(_("automatique"));
664 $form->setSelect("bible_auto",$contenu);
665 // lien bible1
666 $contenu = array(_("bible"));
667 $form->setSelect("bible",$contenu);
668 // lien bible2
669 $contenu = array(_("bible"));
670 $form->setSelect("bible2",$contenu);
671 // lien bible3
672 $contenu = array(_("bible"));
673 $form->setSelect("bible3",$contenu);
674 // lien bible4
675 $contenu = array(_("bible"));
676 $form->setSelect("bible4",$contenu);
677 }
678
679 function cleSecondaire($id, &$db, $val, $DEBUG) {
680 //
681 parent::cleSecondaire($id, $db, $val, $DEBUG);
682
683 $id = $this->getVal($this->clePrimaire);
684
685
686 //Requête de vérification que cet événement d'instruction n'est pas lié
687 //à la création d'un dossier d'instruction
688 $sql = "SELECT demande_type.dossier_instruction_type
689 FROM ".DB_PREFIXE."demande_type
690 LEFT JOIN ".DB_PREFIXE."demande
691 ON demande.demande_type = demande_type.demande_type
692 WHERE demande.instruction_recepisse = ".$id;
693 $res = $this->db->getOne($sql);
694 $this->addToLog("cleSecondaire(): db->getone(\"".$sql."\");", VERBOSE_MODE);
695 if (database::isError($res)) {
696 die($res->getMessage());
697 }
698
699 // Aucune clé secondaire n'a été trouvée ou c'est un événement sans
700 //création de dossier d'instruction, l'événement d'instruction peut être
701 //supprimé
702 if ( $this->correct !== false || $res == null || $res == ""){
703
704 // Requête de vérification que cet événement d'instruction est lié
705 // à une demande
706 $sql = "SELECT demande
707 FROM ".DB_PREFIXE."demande
708 WHERE instruction_recepisse = ".$id;
709 $res = $this->db->getOne($sql);
710 $this->addToLog("cleSecondaire(): db->getone(\"".$sql."\");", VERBOSE_MODE);
711 if (database::isError($res)) {
712 die($res->getMessage());
713 }
714
715 //Si c'est un événement d'instruction lié à une demande
716 if ($res != null || $res != ""){
717
718 require_once "../obj/demande.class.php";
719 $demande = new demande($res, $this->db, DEBUG);
720
721 //On met à jour la demande en supprimant la liaison vers
722 //l'événement d'instruction
723 $demande->setParameter("maj", 1);
724 $valF = array();
725 foreach($demande->champs as $identifiant => $champ) {
726 $valF[$champ] = $demande->val[$identifiant];
727 }
728 $valF['date_demande']=$demande->dateDBToForm($valF['date_demande']);
729 $valF['instruction_recepisse']=NULL;
730 $ret = $demande->modifier($valF, $this->db, DEBUG);
731 }
732
733 /**
734 * Vérification que l'élément supprimé est le dernier pour pouvoir
735 * remodifier les données de manière itérative.
736 */
737 // Initialisation
738 $dernierevenement = "";
739 // Récupération du dernier élément de la table d'instruction qui
740 // concerne le dossier en cours
741 $sql = "SELECT max(instruction)
742 FROM ".DB_PREFIXE."instruction
743 WHERE dossier ='".$this->idxformulaire."'";
744 $dernierevenement = $db->getOne($sql);
745 $this->addToLog("setSelect(): db->getone(\"".$sql."\");", VERBOSE_MODE);
746 if (database::isError($dernierevenement)) {
747 die($dernierevenement->getMessage());
748 }
749 // Si on se trouve effectivement sur le dernier evenement d'instruction
750 if ($dernierevenement == $id) {
751 // Alors on valide la suppression
752 $this->correct = true;
753 $this->addToMessage(_('Destruction_chronologique'));
754 } else {
755 // Alors on annule la suppression
756 $this->correct = false;
757 $this->addToMessage(_("Seul le dernier evenement d'instruction peut etre supprime."));
758 }
759 }
760 }
761
762 /**
763 * Vérification de la possibilité ou non de modifier des dates de suivi
764 * @param string $champ champ date à vérifier
765 */
766 function updateDate($champ) {
767
768 //Si le retourformulaire est "dossier_instruction"
769 if ($this->getParameter("retourformulaire") == "dossier"
770 || $this->getParameter("retourformulaire") == "dossier_instruction"
771 || $this->getParameter("retourformulaire") == "dossier_instruction_mes_encours"
772 || $this->getParameter("retourformulaire") == "dossier_instruction_tous_encours"
773 || $this->getParameter("retourformulaire") == "dossier_instruction_mes_clotures"
774 || $this->getParameter("retourformulaire") == "dossier_instruction_tous_clotures") {
775
776 // Vérification de la possibilité de modifier les dates si déjà éditées
777 if($this->valF[$champ] != "" AND !$this->f->user_is_admin) {
778 // si l'utilisateur n'est pas un admin
779 if($this->getVal($champ) != "" AND $this->getVal($champ) != $this->valF[$champ]) {
780 $this->correct = false;
781 $this->addToMessage(_("Les dates de suivis ne peuvent etre modifiees"));
782 }
783 }
784 }
785
786 //
787 return true;
788 }
789
790 /*Met des valeurs par défaut dans certains des sous-formulaire*/
791 function setValsousformulaire(&$form,$maj,$validation,$idxformulaire,$retourformulaire,$typeformulaire){
792
793 //
794 $this->retourformulaire=$retourformulaire;
795 $this->idxformulaire=$idxformulaire;
796 // Ajout
797 if ($maj == 0) {
798 $form->setVal("destinataire", $idxformulaire);
799 $form->setVal("dossier", $idxformulaire);
800 }
801 //
802 $this->set_form_default_values($form, $maj, $validation);
803 }
804
805 /**
806 * Permet de pré-remplir les valeurs des formulaires.
807 *
808 * @param [object] $form formulaire
809 * @param [integer] $maj mode
810 * @param [integer] $validation validation
811 */
812 function set_form_default_values(&$form, $maj, $validation) {
813
814 // Ajout
815 if ($maj == 0) {
816 if(file_exists ("../sql/".OM_DB_PHPTYPE."/".$this->table.".form.inc.php"))
817 include ("../sql/".OM_DB_PHPTYPE."/".$this->table.".form.inc.php");
818 elseif(file_exists ("../sql/".OM_DB_PHPTYPE."/".$this->table.".form.inc"))
819 include ("../sql/".OM_DB_PHPTYPE."/".$this->table.".form.inc");
820 // si contexte DI
821 if ($this->getParameter("retourformulaire") == "dossier"
822 || $this->getParameter("retourformulaire") == "dossier_instruction"
823 || $this->getParameter("retourformulaire") == "dossier_instruction_mes_encours"
824 || $this->getParameter("retourformulaire") == "dossier_instruction_tous_encours"
825 || $this->getParameter("retourformulaire") == "dossier_instruction_mes_clotures"
826 || $this->getParameter("retourformulaire") == "dossier_instruction_tous_clotures") {
827 // on recupère les signataires de la multicollectivité et de celle du DI
828 require_once "../obj/dossier_instruction.class.php";
829 $di = new dossier_instruction($this->getParameter('idxformulaire'), $db, DEBUG);
830 $sql = str_replace('<collectivite_di>', $di->getVal("om_collectivite"), $sql_signataire_arrete_defaut_by_di);
831 } else {
832 $sql = $sql_signataire_arrete_defaut;
833 }
834 // Date du jour
835 $form->setVal("date_evenement", date('Y-m-d'));
836
837 // Exécution de la requête
838 $res = $this->f->db->query($sql);
839 $this->f->addToLog("setVal(): db->query(\"".$sql."\");", VERBOSE_MODE);
840 if ( database::isError($res)){
841 die();
842 }
843
844 $row = $res->fetchrow(DB_FETCHMODE_ASSOC);
845
846 if (isset($row['signataire_arrete']) && is_numeric($row['signataire_arrete'])){
847 $form->setVal("signataire_arrete",$row['signataire_arrete']);
848 }
849 }
850
851 // Ajout et modification
852 if ($maj == 0 || $maj == 1 || $maj == 125) {
853 $form->setVal("bible_auto","bible_auto()");
854 $form->setVal("bible","bible(1)");
855 $form->setVal("bible2","bible(2)");
856 $form->setVal("bible3","bible(3)");
857 $form->setVal("bible4","bible(4)");
858 }
859 }
860
861
862 function setLayout(&$form, $maj){
863 if ( $maj < 2 OR $maj == 3 OR $maj == 125 ) {
864 /*Champ sur lequel s'ouvre le bloc 1 */
865 $form->setBloc('evenement','D',"","col_12");
866
867 $form->setFieldset('evenement','D',_('Evenement'));
868 $form->setFieldset('om_final_instruction_utilisateur','F','');
869
870 $form->setBloc('om_final_instruction_utilisateur','F');
871
872 $form->setBloc('date_finalisation_courrier','D',"","col_12");
873
874 $form->setFieldset('date_finalisation_courrier','D',_('Dates'));
875 $form->setBloc('date_finalisation_courrier','D',"","col_6");
876 $form->setBloc('date_envoi_controle_legalite','F');
877
878 $form->setBloc('signataire_arrete','D',"","col_6");
879 $form->setBloc('date_retour_controle_legalite','F');
880 $form->setFieldset('date_retour_controle_legalite','F','');
881
882 $form->setBloc('date_retour_controle_legalite','F');
883
884 $form->setBloc('complement_om_html','D',"","col_12");
885 $form->setFieldset('complement_om_html','D',_('Complement'));
886 $form->setFieldset('bible','F','');
887 $form->setBloc('bible','F');
888
889 $form->setBloc('complement2_om_html','D',"","col_12");
890 $form->setFieldset('complement2_om_html','D',_('Complement 2'));
891 $form->setFieldset('bible2','F','');
892 $form->setBloc('bible2','F');
893
894 $form->setBloc('complement3_om_html','D',"","col_12");
895 $form->setFieldset('complement3_om_html','D',_('Complement 3'));
896 $form->setFieldset('bible3','F','');
897 $form->setBloc('bible3','F');
898
899 $form->setBloc('complement4_om_html','D',"","col_12");
900 $form->setFieldset('complement4_om_html','D',_('Complement 4'));
901 $form->setFieldset('bible4','F','');
902 $form->setBloc('bible4','F');
903 }
904 }
905
906 function setLib(&$form, $maj) {
907 //
908 parent::setLib($form, $maj);
909 //
910 $form->setLib('bible_auto', "");
911 $form->setLib('bible', "");
912 $form->setLib('bible2', "");
913 $form->setLib('bible3', "");
914 $form->setLib('bible4', "");
915 $form->setLib('om_final_instruction_utilisateur', _("finalise par"));
916 }
917
918 function triggerajouter($id, &$db, $val, $DEBUG) {
919 /**
920 * Le code suivant permet de récupérer des valeurs des tables evenement
921 * et dossier pour les stocker dans l'instruction :
922 * DEPUIS L'EVENEMENT
923 * - action
924 * - delai
925 * - accord_tacite
926 * - etat
927 * - avis_decision
928 * - delai_notification
929 * - lettretype
930 * - autorite_competente
931 * DEPUIS LE DOSSIER D'INSTRUCTION
932 * - archive_delai
933 * - archive_accord_tacite
934 * - archive_etat
935 * - archive_avis
936 * - date_complet
937 * - date_rejet
938 * - date_limite
939 * - date_notification_delai
940 * - date_decision
941 * - date_validite
942 * - date_achevement
943 * - date_chantier
944 * - date_conformite
945 * - avis_decision
946 */
947 // Récupération de tous les paramètres de l'événement sélectionné
948 $sql = "SELECT * FROM ".DB_PREFIXE."evenement
949 WHERE evenement=".$this->valF['evenement'];
950 $res = $db->query($sql);
951 $this->addToLog("triggerajouter(): db->query(\"".$sql."\");", VERBOSE_MODE);
952 if (database::isError($res)) {
953 die($res->getMessage());
954 }
955 while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
956 // Récupération de l'identifiant de l'action
957 // si une action est paramétrée dans l'événement
958 $this->valF['action'] = NULL;
959 if (isset($row['action']) and !empty($row['action'])) {
960 $this->valF['action']=$row['action'];
961 }
962 // Récupération de la valeur du délai
963 $this->valF['delai'] = $row['delai'];
964 // Récupération de l'identifiant de l'état
965 // si un état est paramétré dans l'événement
966 $this->valF['etat']=NULL;
967 if (isset($row['etat']) and !empty($row['etat'])) {
968 $this->valF['etat']=$row['etat'];
969 }
970 // Récupération de la valeur d'accord tacite
971 $this->valF['accord_tacite']=$row['accord_tacite'];
972 // Récupération de la valeur du délai de notification
973 $this->valF['delai_notification']=$row['delai_notification'];
974 // Récupération de l'identifiant de l'avis
975 // si un avis est paramétré dans l'événement
976 $this->valF['avis_decision'] = NULL;
977 if(isset($row['avis_decision']) and !empty($row['avis_decision'])) {
978 $this->valF['avis_decision']=$row['avis_decision'];
979 }
980 // Récupération de la valeur de l'autorité compétente
981 // si l'autorité compétente est paramétré dans l'événement
982 $this->valF['autorite_competente'] = NULL;
983 if(isset($row['autorite_competente']) and !empty($row['autorite_competente'])) {
984 $this->valF['autorite_competente']=$row['autorite_competente'];
985 }
986 // Récupération de la valeur de la lettre type
987 $this->valF['lettretype']=$row['lettretype'];
988 }
989 // Récupération de toutes les valeurs du dossier d'instruction en cours
990 $sql = "SELECT * FROM ".DB_PREFIXE."dossier
991 WHERE dossier='".$this->valF['dossier']."'";
992 $res = $db->query($sql);
993 $this->addToLog("triggerajouter(): db->query(\"".$sql."\");", VERBOSE_MODE);
994 if (database::isError($res)) {
995 die($res->getMessage());
996 }
997 $row=& $res->fetchRow(DB_FETCHMODE_ASSOC);
998 $this->updateArchiveData($row);
999
1000 // Récupération de la duree de validite du dossier d'autorisation
1001 $sql = "SELECT duree_validite_parametrage
1002 FROM ".DB_PREFIXE."dossier_autorisation_type_detaille
1003 LEFT JOIN ".DB_PREFIXE."dossier_autorisation
1004 ON dossier_autorisation.dossier_autorisation_type_detaille = dossier_autorisation_type_detaille.dossier_autorisation_type_detaille
1005 LEFT JOIN ".DB_PREFIXE."dossier
1006 ON dossier.dossier_autorisation = dossier_autorisation.dossier_autorisation
1007 WHERE dossier.dossier='".$this->valF['dossier']."'";
1008 $duree_validite_parametrage = $db->getOne($sql);
1009 $this->addToLog("triggerajouter(): db->getOne(\"".$sql."\");", VERBOSE_MODE);
1010 database::isError($duree_validite_parametrage);
1011 if ($duree_validite_parametrage != '') {
1012 $this->valF['duree_validite_parametrage']= $duree_validite_parametrage;
1013 }
1014
1015 // Identifiant du type de courrier
1016 $idTypeCourrier = '11';
1017 $idCourrier = str_pad($this->valF["instruction"], 10, "0", STR_PAD_LEFT);
1018 // Code barres
1019 $this->valF["code_barres"] = $idTypeCourrier . $idCourrier;
1020 }
1021
1022 // Test si une restriction est valide
1023 // return boolean
1024 function restrictionIsValid($restriction){
1025 if($this->restriction_valid != null) {
1026 return $this->restriction_valid;
1027 }
1028 if(empty($restriction)) {
1029 $this->restriction_valid = true;
1030 return $this->restriction_valid;
1031 }
1032 // Liste des opérateurs possibles sans espace
1033 $operateurs = array(">=", "<=", "+", "-", "&&", "||", "==", "!=");
1034 // Liste identique mais avec le marqueur §
1035 $mark = "§";
1036 $operateurs_marked = array();
1037 foreach ($operateurs as $operateur) {
1038 $operateurs_marked[] = $mark.$operateur.$mark;
1039 }
1040
1041 // Supprime tous les espaces de la chaîne de caractère
1042 $restriction = preg_replace('/\s+/', '', $restriction);
1043
1044 // Met un marqueur avant et après les opérateurs
1045 // puis transforme la chaine en un tableau
1046 $restriction = str_replace($operateurs, $operateurs_marked,
1047 $restriction);
1048
1049 // Pour chaque opérateur logique
1050 foreach (array('&&', '||') as $operator) {
1051
1052 // S'il est absent on ne fait aucun traitement
1053 if (strpos($restriction, $mark.$operator.$mark) === false) {
1054 continue;
1055 }
1056 // Sinon on vérifie les deux conditions avec le OU/ET logique
1057 $restrictions = explode($mark.$operator.$mark, $restriction);
1058 $restrictions[0] = explode($mark, $restrictions[0]);
1059 $restrictions[1] = explode($mark, $restrictions[1]);
1060 $res_bool = false;
1061 if ($operator == '&&') {
1062 if ($this->is_restriction_satisfied($restrictions[0], $operateurs)
1063 && $this->is_restriction_satisfied($restrictions[1], $operateurs)) {
1064 $res_bool = true;
1065 }
1066 }
1067 if ($operator == '||') {
1068 if ($this->is_restriction_satisfied($restrictions[0], $operateurs)
1069 || $this->is_restriction_satisfied($restrictions[1], $operateurs)) {
1070 $res_bool = true;
1071 }
1072 }
1073 return $res_bool;
1074 }
1075 $tabRestriction = explode($mark, $restriction);
1076 return $this->is_restriction_satisfied($tabRestriction, $operateurs);
1077
1078 }
1079
1080 function is_restriction_satisfied($restriction, $operateurs) {
1081 // Tableau comprenant les résultat
1082 $res = array();
1083 // Compteur pour les résultat
1084 // commence à 1 car le 0 doit rester inchangé tout au long du traitement
1085 $j = 1;
1086 // Comparateur du calcul
1087 $comparateur = '';
1088 // Booléen retourné
1089 $res_bool = true;
1090
1091 // S'il y a un comparateur
1092 if (in_array(">=", $restriction)
1093 || in_array("<=", $restriction)
1094 || in_array("==", $restriction)
1095 || in_array("!=", $restriction)) {
1096
1097 // Si le tableau n'est pas vide
1098 if (count($restriction) > 0) {
1099
1100 // Boucle dans le tableau pour récupérer seulement les valeurs
1101 foreach ($restriction as $key => $value) {
1102 //
1103 if (!in_array($value, $operateurs)) {
1104 if ($this->getRestrictionValue($value) != false) {
1105 $res[] = $this->getRestrictionValue($value);
1106 } else {
1107 // Message d'erreur
1108 $error_message = sprintf(_("Le champ %s de l'instruction %s est vide"), "<span class='bold'>".$value."</span>", "<span class='bold'>".$this->valF["instruction"]."</span>");
1109 $this->addToMessage($error_message);
1110 // Arrête le traitement
1111 return false;
1112 }
1113 }
1114 }
1115
1116 // Boucle dans le tableau
1117 // commence à 1 car le 0 doit rester inchangé tout au long du
1118 // traitement
1119 for ($i = 1; $i<count($restriction); $i++) {
1120
1121 // Récupère le comparateur
1122 if ($restriction[$i] === ">="
1123 || $restriction[$i] === "<="
1124 || $restriction[$i] === "=="
1125 || $restriction[$i] === "!=") {
1126 $comparateur = $restriction[$i];
1127 }
1128
1129 // Si l'opérateur qui suit est un "+"
1130 if ($restriction[$i] === "+") {
1131 $dateDep = $res[$j];
1132 unset($res[$j]);$j++;
1133 $duree = $res[$j];
1134 unset($res[$j]);
1135 $res[$j] = $this->f->mois_date($dateDep, $duree, "+");
1136 }
1137
1138 // Si l'opérateur qui suit est un "-"
1139 if ($restriction[$i] === "-") {
1140 $dateDep = $res[$j];
1141 unset($res[$j]);$j++;
1142 $duree = $res[$j];
1143 unset($res[$j]);
1144 $res[$j] = $this->f->mois_date($dateDep, $duree, "-");
1145 }
1146 }
1147
1148 }
1149
1150 // Si les tableau des résultats n'est pas vide
1151 if (count($res) > 0) {
1152 //
1153 $res_bool = false;
1154 // Effectue le test
1155 if ($comparateur === ">=") {
1156 //
1157 if (strtotime($res[0]) >= strtotime($res[$j])) {
1158 $res_bool = true;
1159 }
1160 }
1161 if ($comparateur === "<=") {
1162 //
1163 if (strtotime($res[0]) <= strtotime($res[$j])) {
1164 $res_bool = true;
1165 }
1166 }
1167 if ($comparateur === "==") {
1168 //
1169 if (strtotime($res[0]) == strtotime($res[$j])) {
1170 $res_bool = true;
1171 }
1172 }
1173 if ($comparateur === "!=") {
1174 //
1175 if (strtotime($res[0]) != strtotime($res[$j])) {
1176 $res_bool = true;
1177 }
1178 }
1179 }
1180 // Sinon une erreur s'affiche
1181 } else {
1182
1183 // Message d'erreur
1184 $error_message = _("Mauvais parametrage de la restriction.")." ".
1185 _("Contactez votre administrateur");
1186 $this->addToMessage($error_message);
1187 // Arrête le traitement
1188 return false;
1189 }
1190
1191 return $res_bool;
1192
1193 }
1194
1195 /**
1196 * Permet de définir si l'événement passé en paramètre est un événement retour.
1197 * @param integer $evenement événement à tester
1198 *
1199 * @return boolean retourne true si événement retour sinon false
1200 */
1201 function is_evenement_retour($evenement) {
1202 if(empty($evenement) || !is_numeric($evenement)) {
1203 return "";
1204 }
1205 $sql = "SELECT retour
1206 FROM ".DB_PREFIXE."evenement
1207 WHERE evenement = ".$evenement;
1208 $retour = $this->db->getOne($sql);
1209 $this->addToLog("verifier(): db->query(\"".$sql."\");", VERBOSE_MODE);
1210 if (database::isError($retour)) {
1211 die($retour->getMessage());
1212 }
1213 if ($retour == 't') {
1214 return true;
1215 } else {
1216 return false;
1217 }
1218 }
1219
1220 /**
1221 * Retourne le champ restriction de l'événement passé en paramètre.
1222 *
1223 * @param integer $evenement id de l'événement sur lequel récupérer la restriction
1224 *
1225 * @return string contenu du champ restriction
1226 */
1227 function get_restriction($evenement) {
1228 if(empty($evenement) || !is_numeric($evenement)) {
1229 return "";
1230 }
1231 //Récupère la restriction
1232 $sql= "SELECT
1233 restriction
1234 FROM
1235 ".DB_PREFIXE."evenement
1236 WHERE
1237 evenement =".$evenement;
1238
1239 $restriction = $this->db->getOne($sql);
1240 $this->addToLog("verifier(): db->query(\"".$sql."\");", VERBOSE_MODE);
1241 if (database::isError($restriction)) {
1242 die($restriction->getMessage());
1243 }
1244 return $restriction;
1245 }
1246
1247 /**
1248 * Récupère la valeur du champ dans la restriction
1249 * @param string $restrictionValue Nom du champ
1250 * @return mixed Valeur du champ
1251 */
1252 function getRestrictionValue($restrictionValue){
1253
1254 // Initialisation de la valeur de retour
1255 $return = false;
1256
1257 // Récupére les valeurs du dossier
1258 $value_dossier = $this->get_dossier_actual();
1259
1260 //
1261 if (is_numeric($restrictionValue)) {
1262 $return = $restrictionValue;
1263 }elseif (isset($value_dossier[$restrictionValue])) {
1264 $return = $value_dossier[$restrictionValue];
1265 }elseif (isset($this->valF[$restrictionValue])) {
1266 $return = $this->valF[$restrictionValue];
1267 }
1268
1269 // Retourne la valeur du champ
1270 return $return;
1271 }
1272
1273 /**
1274 * Calcul des règle d'action.
1275 * @param string $rule Règle d'action
1276 * @param string $rule_name Nom de la règle
1277 * @param string $type Type de la règle
1278 *
1279 * @return mixed Résultat de la règle
1280 */
1281 function regle($rule, $rule_name, $type = null) {
1282
1283 // Supprime tous les espaces de la chaîne de caractère
1284 $rule = str_replace(' ', '', $rule);
1285 // Coupe la chaîne au niveau de l'opérateur
1286 $operands = explode ("+", $rule);
1287 // Nombre d'opérande
1288 $nb_operands = count($operands);
1289
1290 // Règle à null
1291 if ($rule == "null") {
1292 return null;
1293 }
1294
1295 // Si c'est une règle spécifique
1296 if ($rule_name == "regle_autorite_competente"
1297 || $rule_name == "regle_etat"
1298 || $rule_name == "regle_accord_tacite"
1299 || $rule_name == "regle_avis") {
1300 //
1301 return $this->valF[$rule];
1302 }
1303
1304 // Tableau des champs de type date
1305 $rule_type_date = array(
1306 "regle_date_limite",
1307 "regle_date_notification_delai",
1308 "regle_date_complet",
1309 "regle_date_validite",
1310 "regle_date_decision",
1311 "regle_date_chantier",
1312 "regle_date_achevement",
1313 "regle_date_conformite",
1314 "regle_date_rejet",
1315 "regle_date_dernier_depot",
1316 "regle_date_limite_incompletude",
1317 );
1318 // Tableau des champs de type numérique
1319 $rule_type_numeric = array(
1320 "regle_delai",
1321 "regle_delai_incompletude",
1322 );
1323
1324 // Définit le type du champ
1325 if (in_array($rule_name, $rule_type_date) == true) {
1326 $type = "date";
1327 }
1328 if (in_array($rule_name, $rule_type_numeric) == true) {
1329 $type = "numeric";
1330 }
1331
1332 // Initialisation des variables
1333 $key_date = 0;
1334 $total_numeric = 0;
1335
1336 // Pour chaque opérande
1337 foreach ($operands as $key => $operand) {
1338
1339 // Si c'est une règle de type date
1340 if ($type == 'date') {
1341 // Vérifie si au moins une des opérandes est une date
1342 if (!is_numeric($operand)
1343 && isset($this->valF[$operand])
1344 && $this->f->check_date($this->valF[$operand]) == true) {
1345 // Récupère la position de la date
1346 $key_date = $key;
1347 }
1348 // Les autres opérandes doivent être que des numériques
1349 if (is_numeric($operand) == true) {
1350 // Ajoute l'opérande au total
1351 $total_numeric += $operand;
1352 }
1353 if (!is_numeric($operand)
1354 && isset($this->valF[$operand])
1355 && is_numeric($this->valF[$operand]) == true) {
1356 // Ajoute l'opérande au total
1357 $total_numeric += $this->valF[$operand];
1358 }
1359 }
1360
1361 // Si c'est une règle de type numérique
1362 if ($type == 'numeric') {
1363 // Les opérandes doivent être que des numériques
1364 if (is_numeric($operand) == true) {
1365 // Ajoute l'opérande au total
1366 $total_numeric += $operand;
1367 }
1368 if (!is_numeric($operand)
1369 && isset($this->valF[$operand])
1370 && is_numeric($this->valF[$operand]) == true) {
1371 // Ajoute l'opérande au total
1372 $total_numeric += $this->valF[$operand];
1373 }
1374 }
1375 }
1376
1377 // Résultat pour une règle de type date
1378 if ($type == 'date') {
1379 // Retourne le calcul de la date
1380 return $this->f->mois_date($this->valF[$operands[$key_date]],
1381 $total_numeric, "+");
1382 }
1383
1384 // Résultat pour une règle de type numérique
1385 if ($type == 'numeric') {
1386 // Retourne le calcul
1387 return $total_numeric;
1388 }
1389
1390 }
1391
1392 /**
1393 * TRIGGER - triggerajouterapres.
1394 *
1395 * - Mise à jour des informations liées au workflow sur le dossier
1396 * - Interface avec le référentiel ERP [105][111]
1397 * - Mise à jour du DA
1398 * - Historisation de la vie du DI
1399 *
1400 * @return boolean
1401 */
1402 function triggerajouterapres($id, &$db, $val, $DEBUG) {
1403
1404 // On a besoin de l'instance du dossier lié à l'événement d'instruction
1405 $inst_di = $this->get_inst_dossier($this->valF['dossier']);
1406
1407 // Instance de la classe evenement
1408 $inst_evenement = $this->get_inst_evenement($this->valF['evenement']);
1409
1410 /**
1411 * Mise à jour des valeurs du dossier en fonction des valeurs calculées
1412 * par l'action
1413 */
1414 // état de complétude actuel du dossier
1415 $incompletude = ($inst_di->getVal('incompletude') == 't' ? true : false);
1416 // Initialisation
1417 $valF = "";
1418 //
1419 if($incompletude === FALSE) {
1420 // Si l'événement d'instruction est de type incompletude
1421 if($inst_evenement->getVal('type') == "incompletude") {
1422 // On marque le dossier en incomplétude pour application des actions
1423 $incompletude = TRUE;
1424 // Set du flag incomplétude de la table dossier
1425 $valF['incompletude'] = TRUE;
1426 // Enregistrement de l'état dans la variable provisoire
1427 $valF['etat_pendant_incompletude'] = $this->valF['archive_etat'];
1428 }
1429 } else {
1430 // Si l'evenement d'instruction est de type retour ou contient une
1431 // decision, on sort d'incomplétude
1432 if($inst_evenement->getVal('type') == "retour" OR
1433 $inst_evenement->getVal('avis_decision') != NULL) {
1434 // On enlève la marque d'incomplétude pour application des actions
1435 $incompletude = FALSE;
1436 // On enlève le flag d'incomplétude sur l'enregistrement de la table dossier
1437 $valF['incompletude'] = FALSE;
1438 $valF['incomplet_notifie'] = FALSE;
1439 // Restauration de l'état depuis l'état provisoire
1440 $valF['etat'] = $this->valF['archive_etat_pendant_incompletude'];
1441 // On vide la variable provisoire ainsi que le délai de complétude
1442 // et la date limite de complétude
1443 $valF['etat_pendant_incompletude'] = NULL;
1444 $valF['delai_incompletude'] = NULL;
1445 $valF['date_limite_incompletude'] = NULL;
1446 $valF['evenement_suivant_tacite_incompletude'] = NULL;
1447 }
1448 }
1449 // Récupération des paramètres de l'action
1450 $sql = "SELECT * FROM ".DB_PREFIXE."action
1451 WHERE action='".$this->valF['action']."'";
1452 $res = $db->query($sql);
1453 $this->addToLog("triggerajouterapres(): db->query(\"".$sql."\");", VERBOSE_MODE);
1454 if (database::isError($res)) {
1455 die($res->getMessage());
1456 }
1457 while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
1458
1459 // pour chacune des regles, on applique la regle
1460 if($row['regle_delai']!=''){
1461 $valF['delai'] = $this->regle($row['regle_delai'], 'regle_delai');
1462 }
1463 if($row['regle_accord_tacite']!=''){
1464 $valF['accord_tacite'] = $this->regle($row['regle_accord_tacite'], 'regle_accord_tacite');
1465 }
1466 if($row['regle_avis']!=''){
1467 $valF['avis_decision'] = $this->regle($row['regle_avis'], 'regle_avis');
1468 }
1469 if($row['regle_date_limite']!=''){
1470 $valF['date_limite']= $this->regle($row['regle_date_limite'], 'regle_date_limite');
1471 }
1472 if($row['regle_date_complet']!=''){
1473 $valF['date_complet']= $this->regle($row['regle_date_complet'], 'regle_date_complet');
1474 }
1475 if($row['regle_date_dernier_depot']!=''){
1476 $valF['date_dernier_depot']= $this->regle($row['regle_date_dernier_depot'], 'regle_date_dernier_depot');
1477 }
1478 if($row['regle_date_notification_delai']!=''){
1479 $valF['date_notification_delai']= $this->regle($row['regle_date_notification_delai'], 'regle_date_notification_delai');
1480 }
1481 if($row['regle_date_decision']!=''){
1482 $valF['date_decision']= $this->regle($row['regle_date_decision'], 'regle_date_decision');
1483 }
1484 if($row['regle_date_rejet']!=''){
1485 $valF['date_rejet']= $this->regle($row['regle_date_rejet'], 'regle_date_rejet');
1486 }
1487 if($row['regle_date_validite']!=''){
1488 $valF['date_validite']= $this->regle($row['regle_date_validite'], 'regle_date_validite');
1489 }
1490 if($row['regle_date_chantier']!=''){
1491 $valF['date_chantier']= $this->regle($row['regle_date_chantier'], 'regle_date_chantier');
1492 }
1493 if($row['regle_date_achevement']!=''){
1494 $valF['date_achevement']= $this->regle($row['regle_date_achevement'], 'regle_date_achevement');
1495 }
1496 if($row['regle_date_conformite']!=''){
1497 $valF['date_conformite']= $this->regle($row['regle_date_conformite'], 'regle_date_conformite');
1498 }
1499 if($row['regle_date_limite_incompletude']!=''){
1500 $valF['date_limite_incompletude']= $this->regle($row['regle_date_limite_incompletude'], 'regle_date_limite_incompletude');
1501 }
1502 if($row['regle_delai_incompletude']!=''){
1503 $valF['delai_incompletude']= $this->regle($row['regle_delai_incompletude'], 'regle_delai_incompletude');
1504 }
1505 if($row['regle_autorite_competente']!=''){
1506 $valF['autorite_competente']= $this->regle($row['regle_autorite_competente'], 'regle_autorite_competente');
1507 }
1508 if($row['regle_etat']!=''){
1509 // Si on est dans le cas général ou qu'on est en incomplétude et
1510 // qu'on a un événement de type incomplétude alors : on stocke
1511 // l'état dans la variable courante
1512 if ($incompletude == FALSE OR $inst_evenement->getVal('type') == "incompletude") {
1513 $valF['etat'] = $this->regle($row['regle_etat'], 'regle_etat');
1514 } else {
1515 $valF['etat_pendant_incompletude'] = $this->regle($row['regle_etat'], 'regle_etat');
1516 }
1517 }
1518 }
1519 if($this->valEvenement['evenement_suivant_tacite'] != '') {
1520 // Si on est pas en incomplétude on stocke l'événement tacite
1521 //de l'événement dans la variable courante
1522
1523 if ($incompletude == FALSE OR $this->valEvenement['type'] != "incompletude") {
1524 $valF['evenement_suivant_tacite'] = $this->valEvenement['evenement_suivant_tacite'];
1525 } else {
1526 $valF['evenement_suivant_tacite_incompletude'] = $this->valEvenement['evenement_suivant_tacite'];
1527 }
1528 }
1529 // Si des valeurs ont été calculées alors on met à jour l'enregistrement
1530 if ($valF != "") {
1531 // On met à jour le dossier
1532 $cle = " dossier='".$this->valF['dossier']."'";
1533 $res1 = $db->autoExecute(DB_PREFIXE.'dossier', $valF, DB_AUTOQUERY_UPDATE, $cle);
1534 $this->addToLog("triggerajouterapres(): db->autoexecute(\"".DB_PREFIXE."dossier\", ".print_r($valF, true).", DB_AUTOQUERY_UPDATE, \"".$cle."\");", VERBOSE_MODE);
1535 if (database::isError($res1)) {
1536 die($res->getMessage());
1537 }
1538 // Affichage d'informations à l'utilisateur
1539 $this->addToMessage(_('enregistrement')." ".$this->valF['dossier']." "._('table')." dossier [".$db->affectedRows()." "._('enregistrement')." "._('mis_a_jour')."]");
1540 }
1541
1542 /**
1543 * Interface avec le référentiel ERP.
1544 *
1545 * (WS->ERP)[105] Arrêté d'un dossier PC effectué -> PC qui concerne un ERP
1546 * (WS->ERP)[111] Décision de conformité effectuée -> PC qui concerne un ERP
1547 * Déclencheur :
1548 * - L'option ERP est activée
1549 * - Le dossier est marqué comme "connecté au référentiel ERP"
1550 * - Le dossier est de type PC
1551 * - Le formulaire d'ajout d'un événement d'instruction est validé
1552 * avec un événement pour lequel les services ERP doivent être
1553 * informé
1554 */
1555 //
1556 if ($this->f->is_option_referentiel_erp_enabled() === true
1557 && $inst_di->is_connected_to_referentiel_erp() === true
1558 && $this->f->getDATCode($this->valF['dossier']) == $this->f->getParameter('erp__dossier__nature__pc')
1559 && in_array($inst_evenement->getVal($inst_evenement->clePrimaire), explode(";", $this->f->getParameter('erp__evenements__decision__pc')))) {
1560 //
1561 $infos = array(
1562 "dossier_instruction" => $this->valF['dossier'],
1563 "decision" => $inst_evenement->getVal("libelle"),
1564 );
1565 //
1566 $ret = $this->f->send_message_to_referentiel_erp(105, $infos);
1567 if ($ret !== true) {
1568 $this->cleanMessage();
1569 $this->addToMessage(_("Une erreur s'est produite lors de la notification (105) du référentiel ERP. Contactez votre administrateur."));
1570 return false;
1571 }
1572 $this->addToMessage(_("Notification (105) du référentiel ERP OK."));
1573 }
1574
1575 /**
1576 * Mise à jour des données du DA.
1577 */
1578 //
1579 $inst_da = $inst_di->get_inst_dossier_autorisation();
1580 //
1581 if ($inst_da->majDossierAutorisation() === false) {
1582 $this->addToMessage(_("Erreur lors de la mise a jour des donnees du dossier d'autorisation. Contactez votre administrateur."));
1583 $this->correct = false;
1584 return false;
1585 }
1586
1587 /**
1588 * Historisation de la vie du DI.
1589 */
1590 //
1591 return $this->add_log_to_dossier($id, array_merge($val, $this->valF));
1592 }
1593
1594 function triggermodifierapres($id,&$db,$val,$DEBUG) {
1595 /**
1596 * L'objectif ici est d'effectuer les recalculs de date dans le dossier
1597 * si la date de l'evenement est modifiee
1598 */
1599 // Initialisation
1600 $valF = "";
1601 // Initialisation du type d'événement
1602 $type_evmt = "";
1603 // Récupération de l'action correspondante à l'événement
1604 $sql = "SELECT action
1605 FROM ".DB_PREFIXE."evenement
1606 WHERE evenement=".$this->valF['evenement'];
1607 $action = $db->getOne($sql);
1608 $this->addToLog("triggermodifierapres(): db->getone(\"".$sql."\");", VERBOSE_MODE);
1609 if (database::isError($action)) {
1610 die($action->getMessage());
1611 }
1612
1613 // Récupération des paramètres de l'action
1614 $sql = "SELECT * FROM ".DB_PREFIXE."action
1615 WHERE action='".$action."'";
1616 $res = $db->query($sql);
1617 $this->addToLog("triggermodifierapres(): db->query(\"".$sql."\");", VERBOSE_MODE);
1618 if (database::isError($res)) {
1619 die($res->getMessage());
1620 }
1621 while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)){
1622 // application des regles sur le courrier + delai
1623 if(preg_match("/date_evenement/",$row['regle_date_limite'])){
1624 $valF['date_limite']= $this->regle($row['regle_date_limite'], 'regle_date_limite');
1625 }
1626 if(preg_match("/date_evenement/",$row['regle_date_complet'])){
1627 $valF['date_complet']= $this->regle($row['regle_date_complet'], 'regle_date_complet');
1628 }
1629 if(preg_match("/date_evenement/",$row['regle_date_dernier_depot'])){
1630 $valF['date_dernier_depot']= $this->regle($row['regle_date_dernier_depot'], 'regle_date_dernier_depot');
1631 }
1632 if(preg_match("/date_evenement/",$row['regle_date_notification_delai'])){
1633 $valF['date_notification_delai']= $this->regle($row['regle_date_notification_delai'], 'regle_date_notification_delai');
1634 }
1635 if(preg_match("/date_evenement/",$row['regle_date_decision'])){
1636 $valF['date_decision']= $this->regle($row['regle_date_decision'], 'regle_date_decision');
1637 }
1638 if(preg_match("/date_evenement/",$row['regle_date_rejet'])){
1639 $valF['date_rejet']= $this->regle($row['regle_date_rejet'], 'regle_date_rejet');
1640 }
1641 if(preg_match("/date_evenement/",$row['regle_date_validite'])){
1642 $valF['date_validite']= $this->regle($row['regle_date_validite'], 'regle_date_validite');
1643 }
1644 if(preg_match("/date_evenement/",$row['regle_date_chantier'])){
1645 $valF['date_chantier']= $this->regle($row['regle_date_chantier'], 'regle_date_chantier');
1646 }
1647 if(preg_match("/date_evenement/",$row['regle_date_achevement'])){
1648 $valF['date_achevement']= $this->regle($row['regle_date_achevement'], 'regle_date_achevement');
1649 }
1650 if(preg_match("/date_evenement/",$row['regle_date_conformite'])){
1651 $valF['date_conformite']= $this->regle($row['regle_date_conformite'], 'regle_date_conformite');
1652 }
1653 }
1654 // Si des valeurs ont été calculées alors on met à jour l'enregistrement
1655 if ($valF != "") {
1656 // On met à jour le dossier
1657 $cle = " dossier='".$this->valF['dossier']."'";
1658 $res1 = $db->autoExecute(DB_PREFIXE.'dossier', $valF, DB_AUTOQUERY_UPDATE, $cle);
1659 $this->addToLog("triggermodifierapres(): db->autoexecute(\"".DB_PREFIXE."dossier\", ".print_r($valF, true).", DB_AUTOQUERY_UPDATE, \"".$cle."\");", VERBOSE_MODE);
1660 if (database::isError($res1)) {
1661 die($res->getMessage());
1662 }
1663 // Affichage d'informations à l'utilisateur
1664 $this->addToMessage(_('enregistrement')." ".$this->valF['dossier']." "._('table')." dossier [".$db->affectedRows()." "._('enregistrement')." "._('mis_a_jour')."]");
1665 }
1666
1667 $restriction = $this->get_restriction($val['evenement']);
1668 $this->restriction_valid = $this->restrictionIsValid($restriction);
1669
1670 if($restriction == "" || $this->restriction_valid ){
1671 // Récupération de tous les paramètres de l'événement sélectionné
1672 $sql = "SELECT * FROM ".DB_PREFIXE."evenement
1673 WHERE evenement=".$this->valF['evenement'];
1674 $res = $db->query($sql);
1675 $this->addToLog("triggermodifierapres(): db->query(\"".$sql."\");", VERBOSE_MODE);
1676 if (database::isError($res)) {
1677 die($res->getMessage());
1678 }
1679 $current_id = $this->getVal($this->clePrimaire);
1680 while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
1681 // Si la date de retour signature est éditée on vérifie si il existe un événement automatique
1682 if ($this->getVal('date_retour_signature') == "" AND
1683 $this->valF['date_retour_signature'] != "" AND
1684 $row['evenement_retour_signature'] != "") {
1685 $new_instruction = new instruction("]", $db, $DEBUG);
1686 // Création d'un tableau avec la liste des champs de l'instruction
1687 foreach($new_instruction->champs as $champ) {
1688 $valNewInstr[$champ] = "";
1689 }
1690 // Définition des valeurs de la nouvelle instruction
1691 $valNewInstr["evenement"] = $row['evenement_retour_signature'];
1692 $valNewInstr["destinataire"] = $this->valF['destinataire'];
1693 $valNewInstr["dossier"] = $this->valF['dossier'];
1694 $valNewInstr["date_evenement"] = $this->f->formatDate($this->valF['date_retour_signature']);
1695 $valNewInstr["date_envoi_signature"] = $this->f->formatDate($this->valF['date_envoi_signature']);
1696 $valNewInstr["date_retour_signature"] = $this->f->formatDate($this->valF['date_retour_signature']);
1697 $valNewInstr["date_envoi_rar"] = $this->f->formatDate($this->valF['date_envoi_rar']);
1698 $valNewInstr["date_retour_rar"] = $this->f->formatDate($this->valF['date_retour_rar']);
1699 $valNewInstr["date_envoi_controle_legalite"] = $this->f->formatDate($this->valF['date_envoi_controle_legalite']);
1700 $valNewInstr["date_retour_controle_legalite"] = $this->f->formatDate($this->valF['date_retour_controle_legalite']);
1701 $new_instruction->setParameter("maj", 0);
1702 $new_instruction->class_actions[0]["identifier"] =
1703 "retour signature de l'instruction $current_id";
1704 $retour = $new_instruction->ajouter($valNewInstr,$db, $DEBUG);
1705
1706 //Si une erreur s'est produite et qu'il s'agit d'un problème
1707 //de restriction
1708 if ($retour == false && !$new_instruction->restriction_valid){
1709 $error_message = $this->get_restriction_error_message($restriction);
1710 $this->f->displayMessage("error", $error_message);
1711 $this->addToLog("triggermodifierapres() : evenement retour ".
1712 "instruction ".$this->valF[$this->clePrimaire]." : ".
1713 $new_instruction->msg);
1714 }
1715 //Si une erreur s'est produite après le test de la restriction
1716 elseif ($retour == false && $new_instruction->restriction_valid){
1717 $this->correct = false ;
1718 $this->msg .= $new_instruction->msg;
1719 return false;
1720 }
1721 }
1722 // Si la date de retour AR est éditée on vérifie si il existe un événement automatique
1723 if ($this->getVal('date_retour_rar') == "" AND
1724 $this->valF['date_retour_rar'] != "") {
1725
1726 if($row['evenement_retour_ar'] != "") {
1727 $new_instruction = new instruction("]", $db, $DEBUG);
1728 // Création d'un tableau avec la liste des champs de l'instruction
1729 foreach($new_instruction->champs as $champ) {
1730 $valNewInstr[$champ] = "";
1731 }
1732 // Définition des valeurs de la nouvelle instruction
1733 $valNewInstr["evenement"] = $row['evenement_retour_ar'];
1734 $valNewInstr["destinataire"] = $this->valF['destinataire'];
1735 $valNewInstr["dossier"] = $this->valF['dossier'];
1736 $valNewInstr["date_evenement"] = $this->f->formatDate($this->valF['date_retour_rar']);
1737 $valNewInstr["date_envoi_signature"] = $this->f->formatDate($this->valF['date_envoi_signature']);
1738 $valNewInstr["date_retour_signature"] = $this->f->formatDate($this->valF['date_retour_signature']);
1739 $valNewInstr["date_envoi_rar"] = $this->f->formatDate($this->valF['date_envoi_rar']);
1740 $valNewInstr["date_retour_rar"] = $this->f->formatDate($this->valF['date_retour_rar']);
1741 $valNewInstr["date_envoi_controle_legalite"] = $this->f->formatDate($this->valF['date_envoi_controle_legalite']);
1742 $valNewInstr["date_retour_controle_legalite"] = $this->f->formatDate($this->valF['date_retour_controle_legalite']);
1743 $new_instruction->setParameter("maj", 0);
1744 $new_instruction->class_actions[0]["identifier"] =
1745 "retour RAR de l'instruction $current_id";
1746 $retour = $new_instruction->ajouter($valNewInstr,$db, $DEBUG);
1747
1748 //Si une erreur s'est produite et qu'il s'agit d'un problème
1749 //de restriction
1750 if ($retour == false && !$new_instruction->restriction_valid) {
1751 $error_message = $this->get_restriction_error_message($restriction);
1752 $this->f->displayMessage("error", $error_message);
1753 $this->addToLog(
1754 "triggermodifierapres() : evenement retour instruction ".
1755 $this->valF[$this->clePrimaire]." : ".
1756 $new_instruction->msg
1757 );
1758 }
1759 //Si une erreur s'est produite après le test de la restriction
1760 elseif ($retour == false && $new_instruction->restriction_valid){
1761 $this->correct = false ;
1762 $this->msg .= $new_instruction->msg;
1763 return false;
1764 }
1765 }
1766 // Mise à jour du flag incomplet_notifie dans dossier si la
1767 // date limite d'instruction n'est pas dépassée
1768 if($row['type']=='incompletude' &&
1769 ($this->valF['archive_date_notification_delai'] >= $this->valF['date_retour_rar'] ||
1770 $this->valF['archive_date_notification_delai'] == "")) {
1771 $valFIncomp['incomplet_notifie'] = true;
1772 $cle = " dossier='".$val['dossier']."'";
1773 $resIncomp = $db->autoExecute(
1774 DB_PREFIXE.'dossier',
1775 $valFIncomp,
1776 DB_AUTOQUERY_UPDATE,
1777 $cle
1778 );
1779 $this->addToLog(
1780 "triggersupprimer(): db->autoexecute(\"".
1781 DB_PREFIXE."dossier\", ".print_r($valFIncomp, true).
1782 ", DB_AUTOQUERY_UPDATE, \"".$cle."\");",
1783 VERBOSE_MODE
1784 );
1785 if (database::isError($resIncomp)) {
1786 die($resIncomp->getMessage());
1787 }
1788 }
1789 }
1790 }
1791 }
1792
1793 // Mise à jour des données du dossier d'autorisation
1794 require_once "../obj/dossier_autorisation.class.php";
1795 $da = new dossier_autorisation($this->getNumDemandeAutorFromDossier($this->valF['dossier']), $this->db, DEBUG);
1796 if($da->majDossierAutorisation() === false) {
1797 $this->addToMessage(_("Erreur lors de la mise a jour des donnees du dossier d'autorisation. Contactez votre administrateur."));
1798 $this->correct = false;
1799 return false;
1800 }
1801 return $this->add_log_to_dossier($id, $val);
1802 }
1803
1804 function triggersupprimer($id,&$db,$val,$DEBUG) {
1805 /**
1806 * L'objectif ici est de repositionner les valeurs récupérées en
1807 * archive dans le dossier d'instruction avant de supprimer l'événement
1808 * d'instruction
1809 */
1810
1811 // Mise à jour des 4 valeurs modifiées par l'action
1812 $valF['delai'] = $val['archive_delai'];
1813 $valF['accord_tacite'] = $val['archive_accord_tacite'];
1814 $valF['etat'] = $val['archive_etat'];
1815 if ($val['archive_avis'] != '') {
1816 $valF['avis_decision'] = $val['archive_avis'];
1817 } else {
1818 $valF['avis_decision'] = NULL;
1819 }
1820 // Mise à jour des 10 dates avec la valeur présente dans le formulaire
1821 // de suppression. Si la valeur de la date est vide alors on fixe
1822 // à la valeur NULL
1823 //
1824 if ($val['archive_date_complet'] != '') {
1825 $valF['date_complet'] = $val['archive_date_complet'];
1826 } else {
1827 $valF['date_complet'] = NULL;
1828 }
1829 if ($val['archive_date_dernier_depot'] != '') {
1830 $valF['date_dernier_depot'] = $val['archive_date_dernier_depot'];
1831 } else {
1832 $valF['date_dernier_depot'] = NULL;
1833 }
1834 if ($val['archive_date_rejet'] != '') {
1835 $valF['date_rejet'] = $val['archive_date_rejet'];
1836 } else {
1837 $valF['date_rejet'] = NULL;
1838 }
1839 if ($val['archive_date_limite'] != '') {
1840 $valF['date_limite'] = $val['archive_date_limite'];
1841 } else {
1842 $valF['date_limite'] = NULL;
1843 }
1844 if ($val['archive_date_notification_delai'] != '') {
1845 $valF['date_notification_delai'] = $val['archive_date_notification_delai'];
1846 } else {
1847 $valF['date_notification_delai'] = NULL;
1848 }
1849 if ($val['archive_date_decision'] != '') {
1850 $valF['date_decision'] = $val['archive_date_decision'];
1851 } else {
1852 $valF['date_decision'] = NULL;
1853 }
1854 if ($val['archive_date_validite'] != '') {
1855 $valF['date_validite'] = $val['archive_date_validite'];
1856 } else {
1857 $valF['date_validite'] = NULL;
1858 }
1859 if ($val['archive_date_achevement'] != '') {
1860 $valF['date_achevement'] = $val['archive_date_achevement'];
1861 } else {
1862 $valF['date_achevement'] = NULL;
1863 }
1864 if ($val['archive_date_chantier'] != '') {
1865 $valF['date_chantier'] = $val['archive_date_chantier'];
1866 } else {
1867 $valF['date_chantier'] = NULL;
1868 }
1869 if ($val['archive_date_conformite'] != '') {
1870 $valF['date_conformite'] = $val['archive_date_conformite'];
1871 } else {
1872 $valF['date_conformite'] = NULL;
1873 }
1874 if ($val['archive_incompletude'] != '') {
1875 $valF['incompletude'] = $val['archive_incompletude'];
1876 } else {
1877 $valF['incompletude'] = NULL;
1878 }
1879 if ($val['archive_incomplet_notifie'] != '') {
1880 $valF['incomplet_notifie'] = $val['archive_incomplet_notifie'];
1881 } else {
1882 $valF['incomplet_notifie'] = NULL;
1883 }
1884 if ($val['archive_evenement_suivant_tacite'] != '') {
1885 $valF['evenement_suivant_tacite'] = $val['archive_evenement_suivant_tacite'];
1886 } else {
1887 $valF['evenement_suivant_tacite'] = NULL;
1888 }
1889 if ($val['archive_evenement_suivant_tacite_incompletude'] != '') {
1890 $valF['evenement_suivant_tacite_incompletude'] = $val['archive_evenement_suivant_tacite_incompletude'];
1891 } else {
1892 $valF['evenement_suivant_tacite_incompletude'] = NULL;
1893 }
1894 if ($val['archive_etat_pendant_incompletude'] != '') {
1895 $valF['etat_pendant_incompletude'] = $val['archive_etat_pendant_incompletude'];
1896 } else {
1897 $valF['etat_pendant_incompletude'] = NULL;
1898 }
1899 if ($val['archive_date_limite_incompletude'] != '') {
1900 $valF['date_limite_incompletude'] = $val['archive_date_limite_incompletude'];
1901 } else {
1902 $valF['date_limite_incompletude'] = NULL;
1903 }
1904 if ($val['archive_delai_incompletude'] != '') {
1905 $valF['delai_incompletude'] = $val['archive_delai_incompletude'];
1906 } else {
1907 $valF['delai_incompletude'] = NULL;
1908 }
1909 if ($val['archive_autorite_competente'] != '') {
1910 $valF['autorite_competente'] = $val['archive_autorite_competente'];
1911 } else {
1912 $valF['autorite_competente'] = NULL;
1913 }
1914 // On met à jour le dossier
1915 $cle = " dossier='".$val['dossier']."'";
1916 $res = $db->autoExecute(DB_PREFIXE.'dossier', $valF, DB_AUTOQUERY_UPDATE, $cle);
1917 $this->addToLog("triggersupprimer(): db->autoexecute(\"".DB_PREFIXE."dossier\", ".print_r($valF, true).", DB_AUTOQUERY_UPDATE, \"".$cle."\");", VERBOSE_MODE);
1918 if (database::isError($res)) {
1919 die($res->getMessage());
1920 }
1921 // Affichage d'informations à l'utilisateur
1922 $this->addToMessage(_("Suppression de l'instruction")." [".$db->affectedRows()." "._('enregistrement')." "._('mis_a_jour')."]");
1923
1924 // Mise à jour de la demande si un récépissé d'instruction correspond à l'instruction à supprimer
1925 }
1926
1927 function triggersupprimerapres($id,&$db,$val,$DEBUG) {
1928
1929 // Mise à jour des données du dossier d'autorisation
1930 require_once "../obj/dossier_autorisation.class.php";
1931 $da = new dossier_autorisation($this->getNumDemandeAutorFromDossier($val["dossier"]), $this->db, DEBUG);
1932 if($da->majDossierAutorisation() === false) {
1933 $this->addToMessage(_("Erreur lors de la mise a jour des donnees du dossier d'autorisation. Contactez votre administrateur."));
1934 $this->correct = false;
1935 return false;
1936 }
1937 $val['evenement'] = $this->getVal('evenement');
1938 return $this->add_log_to_dossier($id, $val);
1939 }
1940
1941 /**
1942 * Permet de composer un message d'erreur sur restriction non valide en
1943 * fonction du contexte.
1944 *
1945 * @param string $restriction formule de la restriction
1946 *
1947 * @return string message d'erreur
1948 */
1949 function get_restriction_error_message($restriction) {
1950 // Affichage du message si la restriction s'applique
1951 // Contexte du suivi des dates (message simple)
1952 $message_restrict = _("Probleme de dates :");
1953 // Split restriction
1954 $champs_restrict = preg_split(
1955 '/(\W+)/',
1956 $restriction,
1957 null,
1958 PREG_SPLIT_NO_EMPTY|PREG_SPLIT_DELIM_CAPTURE
1959 );
1960 $formated_restrict = "";
1961 // Ajout des chaînes à traduire
1962 foreach ($champs_restrict as $value) {
1963 $formated_restrict .= _($value)." ";
1964 }
1965 $formated_restrict = substr($formated_restrict, 0, -1);
1966 // Message d'erreur dans le contexte du suivi des dates
1967 if($this->getParameter("maj") == 170) {
1968 $message_restrict .= " "._("contactez l'instructeur du dossier");
1969 $message_restrict .= "<br/>(".$formated_restrict.")";
1970 } else {
1971 // Affichage du message si la restriction s'applique
1972 // Contexte instruction
1973 $message_restrict .= "<br/>".$formated_restrict;
1974 }
1975
1976 return $message_restrict;
1977 }
1978
1979 /**
1980 * Vérifie la restriction sur l'événement.
1981 *
1982 * @param array $val valeurs du formulaire
1983 * @param database $db handler database
1984 * @param boolean $DEBUG NA
1985 *
1986 * @return [type] [description]
1987 */
1988 function verifier($val = array(), &$db, $DEBUG) {
1989 parent::verifier($val, $db, $DEBUG);
1990
1991 if ( isset($val['evenement']) && is_numeric($val['evenement'])){
1992 $restriction = $this->get_restriction($val['evenement']);
1993
1994 //Test qu'une restriction est présente
1995 if ($restriction != "" ){
1996
1997 //Test si la restriction est valide
1998 $this->restriction_valid = $this->restrictionIsValid($restriction);
1999 if ( !$this->restriction_valid ){
2000
2001 // Affichage du message si la restriction s'applique
2002 $this->addToMessage(
2003 $this->get_restriction_error_message($restriction)
2004 );
2005 $this->correct=false;
2006 return false;
2007 }
2008
2009 // Liste des opérateurs possible
2010 $operateurs = array(">=", "<=", "+", "-", "&&", "||", "==", "!=");
2011 // Supprime tous les espaces de la chaîne de caractère
2012 $restriction = str_replace(' ', '', $restriction);
2013
2014 // Met des espace avant et après les opérateurs puis transforme la
2015 // chaine en un tableau
2016 $tabRestriction = str_replace($operateurs, " ", $restriction);
2017 // Tableau des champ
2018 $tabRestriction = explode(" ", $tabRestriction);
2019 // Supprime les numériques du tableau
2020 foreach ($tabRestriction as $key => $value) {
2021 if (is_numeric($value)) {
2022 unset($tabRestriction[$key]);
2023 }
2024 }
2025
2026 // Vérifie les champs utilisés pour la restriction
2027 $check_field_exist = $this->f->check_field_exist($tabRestriction, 'instruction');
2028 if ($check_field_exist !== true) {
2029
2030 // Liste des champs en erreur
2031 $string_error_fields = implode(", ", $check_field_exist);
2032
2033 // Message d'erreur
2034 $error_message = _("Le champ %s n'est pas utilisable pour le champ %s");
2035 if (count($check_field_exist) > 1) {
2036 $error_message = _("Les champs %s ne sont pas utilisable pour le champ %s");
2037 }
2038
2039 // Affiche l'erreur
2040 $this->correct=false;
2041 $this->addToMessage(sprintf($error_message, $string_error_fields, _("restriction")));
2042 $this->addToMessage(_("Veuillez contacter votre administrateur."));
2043 }
2044 }
2045
2046 }
2047 if(!$this->updateDate("date_envoi_signature")) {
2048 return false;
2049 }
2050 if(!$this->updateDate("date_retour_signature")) {
2051 return false;
2052 }
2053 if(!$this->updateDate("date_envoi_rar")) {
2054 return false;
2055 }
2056 if(!$this->updateDate("date_retour_rar")) {
2057 return false;
2058 }
2059 if(!$this->updateDate("date_envoi_controle_legalite")) {
2060 return false;
2061 }
2062 if(!$this->updateDate("date_retour_controle_legalite")) {
2063 return false;
2064 }
2065
2066 }
2067
2068 /**
2069 * Finalisation des documents.
2070 * @param string $champ champ du fichier à finaliser
2071 * @param booleen $status permet de définir si on finalise ou définalise
2072 * @param string $sousform permet de savoir si se trouve dans un sousformulaire (passé au javascript)
2073 */
2074 function manage_finalizing($mode = null, $val = array()) {
2075 //
2076 $this->begin_treatment(__METHOD__);
2077
2078 //
2079 $id_inst = $this->getVal($this->clePrimaire);
2080
2081 //
2082 $admin_msg_error = _("Veuillez contacter votre administrateur.");
2083 $file_msg_error = _("Erreur de traitement de fichier.")
2084 ." ".$admin_msg_error;
2085 $bdd_msg_error = _("Erreur de base de données.")
2086 ." ".$admin_msg_error;
2087 $log_msg_error = "Finalisation non enregistrée - id instruction = %s - uid fichier = %s";
2088
2089 // Si on finalise le document
2090 if ($mode == "finalize"){
2091 //
2092 $etat = _('finalisation');
2093
2094 // Récupère la collectivite du dossier d'instruction
2095 $dossier_instruction_om_collectivite = $this->get_dossier_instruction_om_collectivite();
2096
2097 //
2098 $collectivite = $this->f->getCollectivite($dossier_instruction_om_collectivite);
2099
2100 // Génération du PDF
2101 $result = $this->compute_pdf_output('lettretype', $this->getVal('lettretype'), $collectivite);
2102 $pdf_output = $result['pdf_output'];
2103
2104 //Métadonnées du document
2105 $metadata = array(
2106 'filename' => 'instruction_'.$id_inst.'.pdf',
2107 'mimetype' => 'application/pdf',
2108 'size' => strlen($pdf_output)
2109 );
2110
2111 // Récupération des métadonnées calculées après validation
2112 $spe_metadata = $this->getMetadata("om_fichier_instruction");
2113
2114 //On vérifie si l'instruction à finaliser a un événement de type arrete
2115 $sql = "SELECT type
2116 FROM ".DB_PREFIXE."evenement
2117 WHERE evenement = ".$this->getVal("evenement");
2118 $typeEvenement = $this->db->getOne($sql);
2119 $this->addToLog(__METHOD__."(): db->getOne(\"".$sql."\");", VERBOSE_MODE);
2120 if ($this->f->isDatabaseError($typeEvenement, true) === true) {
2121 $this->correct = false;
2122 $this->addToMessage($bdd_msg_error);
2123 return $this->end_treatment(__METHOD__, false);
2124 }
2125
2126 //Initialisation de la variable
2127 $arrete_metadata = array();
2128 // Si l'événement est de type arrete, on ajoute les métadonnées spécifiques
2129 if ( $typeEvenement === 'arrete' ){
2130 $arrete_metadata = $this->getMetadata("arrete");
2131 }
2132
2133 $metadata = array_merge($metadata, $spe_metadata, $arrete_metadata);
2134
2135 // Si le document a déjà été finalisé on le met à jour
2136 // en conservant son UID
2137 if ($this->getVal("om_fichier_instruction") != ''){
2138 $uid = $this->f->storage->update(
2139 $this->getVal("om_fichier_instruction"), $pdf_output, $metadata);
2140 }
2141 // Sinon on crée un nouveau document et dont on récupère l'UID
2142 else {
2143 $uid = $this->f->storage->create($pdf_output, $metadata);
2144 }
2145 }
2146
2147 // Si on définalise le document
2148 if ($mode == "unfinalize") {
2149 //
2150 $etat = _('définalisation');
2151 // Récupération de l'uid du document finalisé
2152 $uid = $this->getVal("om_fichier_instruction");
2153 }
2154
2155 // Si on définalise l'UID doit être défini
2156 // Si on finalise la création/modification du fichier doit avoir réussi
2157 if ($uid == '' || $uid == 'OP_FAILURE' ) {
2158 $this->correct = false;
2159 $this->addToMessage($file_msg_error);
2160 $this->addToLog(sprintf($log_msg_error, $id_inst, $uid));
2161 return $this->end_treatment(__METHOD__, false);
2162 }
2163
2164 //
2165 foreach ($this->champs as $key => $champ) {
2166 //
2167 $val[$champ] = $this->val[$key];
2168 }
2169
2170 //
2171 $val['date_evenement']=$this->dateDBToForm($val['date_evenement']);
2172 $val['archive_date_complet']=$this->dateDBToForm($val['archive_date_complet']);
2173 $val['archive_date_rejet']=$this->dateDBToForm($val['archive_date_rejet']);
2174 $val['archive_date_limite']=$this->dateDBToForm($val['archive_date_limite']);
2175 $val['archive_date_notification_delai']=$this->dateDBToForm($val['archive_date_notification_delai']);
2176 $val['archive_date_decision']=$this->dateDBToForm($val['archive_date_decision']);
2177 $val['archive_date_validite']=$this->dateDBToForm($val['archive_date_validite']);
2178 $val['archive_date_achevement']=$this->dateDBToForm($val['archive_date_achevement']);
2179 $val['archive_date_chantier']=$this->dateDBToForm($val['archive_date_chantier']);
2180 $val['archive_date_conformite']=$this->dateDBToForm($val['archive_date_conformite']);
2181 $val['archive_date_dernier_depot']=$this->dateDBToForm($val['archive_date_dernier_depot']);
2182 $val['archive_date_limite_incompletude']=$this->dateDBToForm($val['archive_date_limite_incompletude']);
2183 $val['date_finalisation_courrier']=$this->dateDBToForm($val['date_finalisation_courrier']);
2184 $val['date_envoi_signature']=$this->dateDBToForm($val['date_envoi_signature']);
2185 $val['date_retour_signature']=$this->dateDBToForm($val['date_retour_signature']);
2186 $val['date_envoi_rar']=$this->dateDBToForm($val['date_envoi_rar']);
2187 $val['date_retour_rar']=$this->dateDBToForm($val['date_retour_rar']);
2188 $val['date_envoi_controle_legalite']=$this->dateDBToForm($val['date_envoi_controle_legalite']);
2189 $val['date_retour_controle_legalite']=$this->dateDBToForm($val['date_retour_controle_legalite']);
2190 $this->setvalF($val);
2191
2192 // Verification de la validite des donnees
2193 $this->verifier($this->val, $this->db, DEBUG);
2194 // Si les verifications precedentes sont correctes, on procede a
2195 // la modification, sinon on ne fait rien et on retourne une erreur
2196 if ($this->correct === true) {
2197 //
2198 $valF = array(
2199 "om_fichier_instruction" => $uid,
2200 "date_finalisation_courrier" => date('Y-m-d')
2201 );
2202 //
2203 if($mode=="finalize") {
2204 // état finalisé vrai
2205 $valF["om_final_instruction"] = true;
2206 // ajout log utilisateur
2207 $login = $_SESSION['login'];
2208 $nom = "";
2209 $this->f->getUserInfos();
2210 if (isset($this->f->om_utilisateur["nom"])
2211 && !empty($this->f->om_utilisateur["nom"])) {
2212 $nom = $this->f->om_utilisateur["nom"];
2213 }
2214 $valF["om_final_instruction_utilisateur"] = $_SESSION['login'];
2215 if ($nom != "") {
2216 $valF["om_final_instruction_utilisateur"] .= " (".$nom.")";
2217 }
2218 } else {
2219 // état finalisé faux
2220 $valF["om_final_instruction"] = false;
2221 // suppression log utilisateur
2222 $valF["om_final_instruction_utilisateur"] = '';
2223 }
2224
2225 // Execution de la requête de modification des donnees de l'attribut
2226 // valF de l'objet dans l'attribut table de l'objet
2227 $res = $this->db->autoExecute(DB_PREFIXE.$this->table, $valF,
2228 DB_AUTOQUERY_UPDATE, $this->getCle($id_inst));
2229 $this->addToLog(__METHOD__."() : db->autoExecute(\"".DB_PREFIXE.$this->table."\", ".print_r($valF, true).", DB_AUTOQUERY_UPDATE, \"".$this->getCle($id_inst)."\")", VERBOSE_MODE);
2230 //
2231 if ($this->f->isDatabaseError($res, true) === true) {
2232 $this->correct = false;
2233 $this->addToMessage($bdd_msg_error);
2234 return $this->end_treatment(__METHOD__, false);
2235 }
2236
2237 //
2238 $this->addToMessage(sprintf(_("La %s du document s'est effectuee avec succes."), $etat));
2239 //
2240 if ($this->add_log_to_dossier($id_inst, $val) === false) {
2241 return $this->end_treatment(__METHOD__, false);
2242 }
2243 //
2244 return $this->end_treatment(__METHOD__, true);
2245 }
2246 // L'appel de verifier() a déjà positionné correct à false
2247 // et défini un message d'erreur.
2248 $this->addToLog(sprintf($log_msg_error, $id_inst, $uid));
2249 return $this->end_treatment(__METHOD__, false);
2250 }
2251
2252 /**
2253 * Récupération du numéro de dossier d'instruction à ajouter aux métadonnées
2254 * @return string numéro de dossier d'instruction
2255 */
2256 protected function getDossier() {
2257 if(empty($this->specificMetadata)) {
2258 $this->getSpecificMetadata();
2259 }
2260 return $this->specificMetadata->dossier;
2261 }
2262 /**
2263 * Récupération la version du dossier d'instruction à ajouter aux métadonnées
2264 * @return int Version
2265 */
2266 protected function getDossierVersion() {
2267 if(empty($this->specificMetadata)) {
2268 $this->getSpecificMetadata();
2269 }
2270 return $this->specificMetadata->version;
2271 }
2272 /**
2273 * Récupération du numéro de dossier d'autorisation à ajouter aux métadonnées
2274 * @return string numéro de dossier d'autorisation
2275 */
2276 protected function getNumDemandeAutor() {
2277 if(empty($this->specificMetadata)) {
2278 $this->getSpecificMetadata();
2279 }
2280 return $this->specificMetadata->dossier_autorisation;
2281 }
2282 /**
2283 * Récupération de la date de demande initiale du dossier à ajouter aux métadonnées
2284 * @return date de la demande initiale
2285 */
2286 protected function getAnneemoisDemandeAutor() {
2287 if(empty($this->specificMetadata)) {
2288 $this->getSpecificMetadata();
2289 }
2290 return $this->specificMetadata->date_demande_initiale;
2291 }
2292 /**
2293 * Récupération du type de dossier d'instruction à ajouter aux métadonnées
2294 * @return string type du dossier d'instruction
2295 */
2296 protected function getTypeInstruction() {
2297 if(empty($this->specificMetadata)) {
2298 $this->getSpecificMetadata();
2299 }
2300 return $this->specificMetadata->dossier_instruction_type;
2301 }
2302 /**
2303 * Récupération du statut du dossier d'autorisation à ajouter aux métadonnées
2304 * @return string avis
2305 */
2306 protected function getStatutAutorisation() {
2307 if(empty($this->specificMetadata)) {
2308 $this->getSpecificMetadata();
2309 }
2310 return $this->specificMetadata->statut;
2311 }
2312 /**
2313 * Récupération du type de dossier d'autorisation à ajouter aux métadonnées
2314 * @return string type du dossier d'autorisation
2315 */
2316 protected function getTypeAutorisation() {
2317 if(empty($this->specificMetadata)) {
2318 $this->getSpecificMetadata();
2319 }
2320 return $this->specificMetadata->dossier_autorisation_type;
2321 }
2322 /**
2323 * Récupération de la date d'ajout de document à ajouter aux métadonnées
2324 * @return date de l'évènement
2325 */
2326 protected function getDateEvenementDocument() {
2327 return date("Y-m-d");
2328 }
2329 /**
2330 * Récupération du groupe d'instruction à ajouter aux métadonnées
2331 * @return string Groupe d'instruction
2332 */
2333 protected function getGroupeInstruction() {
2334 if(empty($this->specificMetadata)) {
2335 $this->getSpecificMetadata();
2336 }
2337 return $this->specificMetadata->groupe_instruction;
2338 }
2339 /**
2340 * Récupération du libellé du type du document à ajouter aux métadonnées
2341 * @return string Groupe d'instruction
2342 */
2343 protected function getTitle() {
2344
2345 // Récupère le champ événement
2346 if (isset($this->valF["evenement"]) AND $this->valF["evenement"] != "") {
2347 $evenement = $this->valF["evenement"];
2348 } else {
2349 $evenement = $this->getVal("evenement");
2350 }
2351
2352 // Requête sql
2353 $sql = "SELECT libelle FROM ".DB_PREFIXE."evenement
2354 WHERE evenement=".$evenement;
2355 $evenement_libelle = $this->db->getOne($sql);
2356 $this->addToLog("getTitle(): db->getOne(\"".$sql."\");", VERBOSE_MODE);
2357 if (database::isError($evenement_libelle)) {
2358 die();
2359 }
2360
2361 // Retourne le libelle de l'événement
2362 return $evenement_libelle;
2363 }
2364
2365 /**
2366 * Cette méthode permet de stocker en attribut toutes les métadonnées
2367 * nécessaire à l'ajout d'un document.
2368 */
2369 public function getSpecificMetadata() {
2370 if (isset($this->valF["dossier"]) AND $this->valF["dossier"] != "") {
2371 $dossier = $this->valF["dossier"];
2372 } else {
2373 $dossier = $this->getVal("dossier");
2374 }
2375 //Requête pour récupérer les informations essentiels sur le dossier d'instruction
2376 $sql = "SELECT dossier.dossier as dossier,
2377 dossier_autorisation.dossier_autorisation as dossier_autorisation,
2378 to_char(dossier.date_demande, 'YYYY/MM') as date_demande_initiale,
2379 dossier_instruction_type.code as dossier_instruction_type,
2380 etat_dossier_autorisation.libelle as statut,
2381 dossier_autorisation_type.code as dossier_autorisation_type,
2382 groupe.code as groupe_instruction
2383 FROM ".DB_PREFIXE."dossier
2384 LEFT JOIN ".DB_PREFIXE."dossier_instruction_type
2385 ON dossier.dossier_instruction_type = dossier_instruction_type.dossier_instruction_type
2386 LEFT JOIN ".DB_PREFIXE."dossier_autorisation
2387 ON dossier.dossier_autorisation = dossier_autorisation.dossier_autorisation
2388 LEFT JOIN ".DB_PREFIXE."etat_dossier_autorisation
2389 ON dossier_autorisation.etat_dossier_autorisation = etat_dossier_autorisation.etat_dossier_autorisation
2390 LEFT JOIN ".DB_PREFIXE."dossier_autorisation_type_detaille
2391 ON dossier_autorisation.dossier_autorisation_type_detaille = dossier_autorisation_type_detaille.dossier_autorisation_type_detaille
2392 LEFT JOIN ".DB_PREFIXE."dossier_autorisation_type
2393 ON dossier_autorisation_type_detaille.dossier_autorisation_type = dossier_autorisation_type.dossier_autorisation_type
2394 LEFT JOIN ".DB_PREFIXE."groupe
2395 ON dossier_autorisation_type.groupe = groupe.groupe
2396 WHERE dossier.dossier = '".$dossier."'";
2397 $res = $this->db->query($sql);
2398 $this->f->addToLog("getSpecificMetadata() : db->query(".$sql.")", VERBOSE_MODE);
2399 if ( database::isError($res)){
2400 die();
2401 }
2402
2403 //Le résultat est récupéré dans un objet
2404 $row =& $res->fetchRow(DB_FETCHMODE_OBJECT);
2405
2406 //Si il y a un résultat
2407 if ($row !== null) {
2408
2409 // Instrance de la classe dossier
2410 $inst_dossier = $this->get_inst_dossier($dossier);
2411
2412 // Insère l'attribut version à l'objet
2413 $row->version = $inst_dossier->get_dossier_instruction_version();
2414
2415 //Alors on créé l'objet dossier_instruction
2416 $this->specificMetadata = $row;
2417
2418 }
2419 }
2420
2421 /**
2422 * Retourne le statut du dossier d'instruction
2423 * @param string $idx Identifiant du dossier d'instruction
2424 * @return string Le statut du dossier d'instruction
2425 */
2426 function getStatutAutorisationDossier($idx){
2427
2428 $statut = '';
2429
2430 //Si l'identifiant du dossier d'instruction fourni est correct
2431 if ( $idx != '' ){
2432
2433 //On récupère le statut de l'état du dossier à partir de l'identifiant du
2434 //dossier
2435 $sql = "SELECT etat.statut
2436 FROM ".DB_PREFIXE."dossier
2437 LEFT JOIN
2438 ".DB_PREFIXE."etat
2439 ON
2440 dossier.etat = etat.etat
2441 WHERE dossier ='".$idx."'";
2442 $statut = $this->db->getOne($sql);
2443 $this->f->addToLog("getStatutAutorisationDossier() : db->getOne(\"".$sql."\")", VERBOSE_MODE);
2444 if ( database::isError($statut)){
2445 die();
2446 }
2447 }
2448 return $statut;
2449 }
2450
2451 /**
2452 * Récupère les données du dossier
2453 * @return array
2454 */
2455 function get_dossier_actual() {
2456
2457 // Initialisation de la valeur de retour
2458 $return = array();
2459
2460 // Récupération de toutes les valeurs du dossier d'instruction en cours
2461 $sql = "SELECT * FROM ".DB_PREFIXE."dossier
2462 WHERE dossier='".$this->valF['dossier']."'";
2463 $res = $this->db->query($sql);
2464 $this->addToLog("get_dossier_actual(): db->query(\"".$sql."\");", VERBOSE_MODE);
2465 $this->f->isDatabaseError($res);
2466
2467 //
2468 while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
2469
2470 // Récupération de la valeur actuelle du délai, de l'accord tacite,
2471 // de l'état et de l'avis du dossier d'instruction
2472 $return['archive_delai']=$row['delai'];
2473 $return['archive_accord_tacite']=$row['accord_tacite'];
2474 $return['archive_etat']=$row['etat'];
2475 $return['archive_avis']=$row['avis_decision'];
2476 // Récupération de la valeur actuelle des 9 dates du dossier
2477 // d'instruction
2478 $return['archive_date_complet']=$row['date_complet'];
2479 $return['archive_date_dernier_depot']=$row['date_dernier_depot'];
2480 $return['archive_date_rejet']= $row['date_rejet'];
2481 $return['archive_date_limite']= $row['date_limite'];
2482 $return['archive_date_notification_delai']= $row['date_notification_delai'];
2483 $return['archive_date_decision']= $row['date_decision'];
2484 $return['archive_date_validite']= $row['date_validite'];
2485 $return['archive_date_achevement']= $row['date_achevement'];
2486 $return['archive_date_chantier']= $row['date_chantier'];
2487 $return['archive_date_conformite']= $row['date_conformite'];
2488 $return['archive_incompletude']= $row['incompletude'];
2489 $return['archive_incomplet_notifie']= $row['incomplet_notifie'];
2490 $return['archive_evenement_suivant_tacite']= $row['evenement_suivant_tacite'];
2491 $return['archive_evenement_suivant_tacite_incompletude']= $row['evenement_suivant_tacite_incompletude'];
2492 $return['archive_etat_pendant_incompletude']= $row['etat_pendant_incompletude'];
2493 $return['archive_date_limite_incompletude']= $row['date_limite_incompletude'];
2494 $return['archive_delai_incompletude']= $row['delai_incompletude'];
2495 $return['archive_autorite_competente']= $row['autorite_competente'];
2496 $return['duree_validite']= $row['duree_validite'];
2497 $return['date_depot']= $row['date_depot'];
2498 }
2499
2500 // Retour de la fonction
2501 return $return;
2502
2503 }
2504
2505 /**
2506 * Permet de vérifier qu'un événement est verrouillable
2507 * @param integer $idx Identifiant de l'instruction
2508 * @return boolean
2509 */
2510 function checkEvenementNonVerrouillable($idx) {
2511
2512 // Initialisation du résultat
2513 $non_verrouillable = false;
2514
2515 // Si la condition n'est pas vide
2516 if ($idx != "") {
2517
2518 // Requête SQL
2519 $sql = "SELECT evenement.non_verrouillable
2520 FROM ".DB_PREFIXE."evenement
2521 LEFT JOIN ".DB_PREFIXE."instruction
2522 ON instruction.evenement = evenement.evenement
2523 WHERE instruction.instruction = $idx";
2524 $this->f->addToLog("checkEvenementNonVerrouillable() : db->getOne(\"".$sql."\")", VERBOSE_MODE);
2525 $res = $this->db->getOne($sql);
2526 $this->f->isDatabaseError($res);
2527
2528 // Si le retour de la requête est true
2529 if ($res == 't') {
2530 //
2531 $non_verrouillable = true;
2532 }
2533 }
2534
2535 // Retourne résultat
2536 return $non_verrouillable;
2537 }
2538
2539 /**
2540 * Mise à jour des champs archive_*
2541 * @param mixed $row La ligne de données
2542 */
2543 public function updateArchiveData($row){
2544
2545 // Récupération de la valeur actuelle du délai, de l'accord tacite,
2546 // de l'état et de l'avis du dossier d'instruction
2547 $this->valF['archive_delai']=$row['delai'];
2548 $this->valF['archive_accord_tacite']=$row['accord_tacite'];
2549 $this->valF['archive_etat']=$row['etat'];
2550 $this->valF['archive_avis']=$row['avis_decision'];
2551 // Récupération de la valeur actuelle des 9 dates du dossier
2552 // d'instruction
2553 if ($row['date_complet'] != '') {
2554 $this->valF['archive_date_complet']=$row['date_complet'];
2555 }
2556 if ($row['date_dernier_depot'] != '') {
2557 $this->valF['archive_date_dernier_depot']=$row['date_dernier_depot'];
2558 }
2559 if ($row['date_rejet']!='') {
2560 $this->valF['archive_date_rejet']= $row['date_rejet'];
2561 }
2562 if ($row['date_limite']!='') {
2563 $this->valF['archive_date_limite']= $row['date_limite'];
2564 }
2565 if ($row['date_notification_delai']!='') {
2566 $this->valF['archive_date_notification_delai']= $row['date_notification_delai'];
2567 }
2568 if ($row['date_decision']!='') {
2569 $this->valF['archive_date_decision']= $row['date_decision'];
2570 }
2571 if ($row['date_validite']!='') {
2572 $this->valF['archive_date_validite']= $row['date_validite'];
2573 }
2574 if ($row['date_achevement']!='') {
2575 $this->valF['archive_date_achevement']= $row['date_achevement'];
2576 }
2577 if ($row['date_chantier']!='') {
2578 $this->valF['archive_date_chantier']= $row['date_chantier'];
2579 }
2580 if ($row['date_conformite']!='') {
2581 $this->valF['archive_date_conformite']= $row['date_conformite'];
2582 }
2583 if ($row['incompletude']!='') {
2584 $this->valF['archive_incompletude']= $row['incompletude'];
2585 }
2586 if ($row['incomplet_notifie']!='') {
2587 $this->valF['archive_incomplet_notifie']= $row['incomplet_notifie'];
2588 }
2589 if ($row['evenement_suivant_tacite']!='') {
2590 $this->valF['archive_evenement_suivant_tacite']= $row['evenement_suivant_tacite'];
2591 }
2592 if ($row['evenement_suivant_tacite_incompletude']!='') {
2593 $this->valF['archive_evenement_suivant_tacite_incompletude']= $row['evenement_suivant_tacite_incompletude'];
2594 }
2595 if ($row['etat_pendant_incompletude']!='') {
2596 $this->valF['archive_etat_pendant_incompletude']= $row['etat_pendant_incompletude'];
2597 }
2598 if ($row['date_limite_incompletude']!='') {
2599 $this->valF['archive_date_limite_incompletude']= $row['date_limite_incompletude'];
2600 }
2601 if ($row['delai_incompletude']!='') {
2602 $this->valF['archive_delai_incompletude']= $row['delai_incompletude'];
2603 }
2604 if ($row['autorite_competente']!='') {
2605 $this->valF['archive_autorite_competente']= $row['autorite_competente'];
2606 }
2607 if ($row['duree_validite']!='') {
2608 $this->valF['duree_validite']= $row['duree_validite'];
2609 }
2610 if ($row['date_depot']!='') {
2611 $this->valF['date_depot']= $row['date_depot'];
2612 }
2613 }
2614
2615 // {{{
2616 // Méthodes de récupération des métadonnées arrêté
2617 /**
2618 * @return string Retourne le numéro d'arrêté
2619 */
2620 function getNumArrete() {
2621 return $this->getVal("numero_arrete");
2622 }
2623 /**
2624 * @return chaîne vide
2625 */
2626 function getReglementaireArrete() {
2627 return 'true';
2628 }
2629 /**
2630 * @return boolean de notification au pétitionnaire
2631 */
2632 function getNotificationArrete() {
2633 return 'true';
2634 }
2635 /**
2636 * @return date de notification au pétitionnaire
2637 */
2638 function getDateNotificationArrete() {
2639 if (empty($this->metadonneesArrete)) {
2640 $this->getArreteMetadata();
2641 }
2642 return $this->metadonneesArrete["datenotification"];
2643 }
2644 /**
2645 * @return boolean check si le document est passé au contrôle de légalité
2646 */
2647 function getControleLegalite() {
2648 return 'true';
2649 }
2650 /**
2651 * @return date de signature de l'arrêté
2652 */
2653 function getDateSignature() {
2654 if (empty($this->metadonneesArrete)) {
2655 $this->getArreteMetadata();
2656 }
2657 return $this->metadonneesArrete["datesignaturearrete"];
2658 }
2659 /**
2660 * @return string nom du signataire
2661 */
2662 function getNomSignataire() {
2663 if (empty($this->metadonneesArrete)) {
2664 $this->getArreteMetadata();
2665 }
2666 return $this->metadonneesArrete["nomsignataire"];
2667 }
2668 /**
2669 * @return string qualité du signataire
2670 */
2671 function getQualiteSignataire() {
2672 if (empty($this->metadonneesArrete)) {
2673 $this->getArreteMetadata();
2674 }
2675 return $this->metadonneesArrete["qualitesignataire"];
2676 }
2677 /**
2678 * @return string numéro du terrain
2679 */
2680 function getAp_numRue() {
2681 if (empty($this->metadonneesArrete)) {
2682 $this->getArreteMetadata();
2683 }
2684 return $this->metadonneesArrete["ap_numrue"];
2685 }
2686 /**
2687 * @return string nom de la rue du terrain
2688 */
2689 function getAp_nomDeLaVoie() {
2690 if (empty($this->metadonneesArrete)) {
2691 $this->getArreteMetadata();
2692 }
2693 return $this->metadonneesArrete["ap_nomdelavoie"];
2694 }
2695 /**
2696 * @return string code postal du terrain
2697 */
2698 function getAp_codePostal() {
2699 if (empty($this->metadonneesArrete)) {
2700 $this->getArreteMetadata();
2701 }
2702 return $this->metadonneesArrete["ap_codepostal"];
2703 }
2704 /**
2705 * @return string ville du terrain
2706 */
2707 function getAp_ville() {
2708 if (empty($this->metadonneesArrete)) {
2709 $this->getArreteMetadata();
2710 }
2711 return $this->metadonneesArrete["ap_ville"];
2712 }
2713 /**
2714 * @return string activité
2715 */
2716 function getActivite() {
2717 return "Droit du sol";
2718 }
2719 /**
2720 * @return string date du retour de controle légalité
2721 */
2722 function getDateControleLegalite() {
2723 if (empty($this->metadonneesArrete)) {
2724 $this->getArreteMetadata();
2725 }
2726 return $this->metadonneesArrete["datecontrolelegalite"];
2727 }
2728
2729 // Fin des méthodes de récupération des métadonnées
2730 // }}}
2731
2732 /**
2733 * Méthode de récupération des métadonnées arrêtés dans la base de données,
2734 * les données sont stockés dans l'attribut $this->metadonneesArrete
2735 */
2736 function getArreteMetadata() {
2737
2738 //Récupération de la dernière instruction dont l'événement est de type 'arrete'
2739 $this->metadonneesArrete = array("nomsignataire"=>"", "qualitesignataire"=>"",
2740 "decisionarrete"=>"", "datenotification"=>"", "datesignaturearrete"=>"",
2741 "datecontrolelegalite"=>"", "ap_numrue"=>"", "ap_nomdelavoie"=>"",
2742 "ap_codepostal"=>"", "ap_ville"=>"");
2743
2744 $sqlArrete = "SELECT signataire_arrete.nom as \"nomsignataire\",
2745 signataire_arrete.qualite as \"qualitesignataire\",
2746 instruction.etat as \"decisionarrete\",
2747 instruction.date_retour_rar as \"datenotification\",
2748 instruction.date_retour_signature as \"datesignaturearrete\",
2749 instruction.date_retour_controle_legalite as \"datecontrolelegalite\",
2750 dossier.terrain_adresse_voie_numero as \"ap_numrue\",
2751 dossier.terrain_adresse_voie as \"ap_nomdelavoie\",
2752 dossier.terrain_adresse_code_postal as \"ap_codepostal\",
2753 dossier.terrain_adresse_localite as \"ap_ville\"
2754 FROM ".DB_PREFIXE."instruction
2755 LEFT JOIN ".DB_PREFIXE."signataire_arrete ON
2756 instruction.signataire_arrete = signataire_arrete.signataire_arrete
2757 LEFT JOIN ".DB_PREFIXE."dossier ON
2758 instruction.dossier = dossier.dossier
2759 LEFT JOIN ".DB_PREFIXE."donnees_techniques ON
2760 donnees_techniques.dossier_instruction = dossier.dossier
2761 WHERE instruction.instruction = ".$this->getVal("instruction");
2762 $resArrete = $this->db->query($sqlArrete);
2763 $this->f->addToLog("getArreteMetadata(): db->query(\"".$sqlArrete."\");", VERBOSE_MODE);
2764 if ( database::isError($resArrete)){
2765 die();
2766 }
2767
2768 $this->metadonneesArrete = $resArrete->fetchRow(DB_FETCHMODE_ASSOC);
2769 }
2770
2771 /**
2772 * CONDITION - has_an_edition.
2773 *
2774 * Condition pour afficher le bouton de visualisation de l'édition.
2775 *
2776 * @return boolean
2777 */
2778 function has_an_edition() {
2779 // Récupère la valeur du champ lettretype
2780 $lettretype = $this->getVal("lettretype");
2781 // Si le champ est vide
2782 if (empty($lettretype)) {
2783 //
2784 return false;
2785 }
2786
2787 //
2788 return true;
2789 }
2790
2791 /**
2792 * CONDITION - is_editable.
2793 *
2794 * Condition pour la modification.
2795 *
2796 * @return boolean
2797 */
2798 function is_editable() {
2799 // Contrôle si l'utilisateur possède un bypass
2800 $bypass = $this->f->isAccredited(get_class()."_modifier_bypass");
2801 //
2802 if ($bypass == true) {
2803
2804 //
2805 return true;
2806 }
2807
2808 // Si l'utilisateur est un intructeur qui ne correspond pas à la
2809 // division du dossier
2810 if ($this->f->isUserInstructeur()
2811 && $this->f->om_utilisateur["division"] != $this->getDivisionFromDossier()
2812 && $this->f->isAccredited(array("instruction", "instruction_changer_decision"), "OR") === false) {
2813
2814 //
2815 return false;
2816 }
2817
2818 // si instructeur commune
2819 if($this->f->isAccredited(array("instruction", "instruction_changer_decision"), "OR") === true
2820 && $this->f->om_utilisateur["division"] != $this->getDivisionFromDossier()
2821 && ($this->f->isInstrCanChangeDecision($this->getVal('dossier')) !== true
2822 || $this->getVal('created_by_commune') !== 't')) {
2823 return false;
2824 }
2825 // Si l'utilisateur est un instructeur, que le dossier est cloturé et
2826 // que l'événement n'est pas identifié comme non verrouillable
2827 if ($this->f->isUserInstructeur()
2828 && $this->getStatutAutorisationDossier($this->getParameter("idxformulaire")) == "cloture"
2829 && $this->checkEvenementNonVerrouillable($this->getVal("instruction")) === false) {
2830
2831 //
2832 return false;
2833 }
2834
2835 //
2836 return true;
2837 }
2838
2839 /**
2840 * CONDITION - is_deletable.
2841 *
2842 * Condition pour lma modification.
2843 *
2844 * @return boolean
2845 */
2846 function is_deletable() {
2847 // Contrôle si l'utilisateur possède un bypass
2848 $bypass = $this->f->isAccredited(get_class()."_supprimer_bypass");
2849 //
2850 if ($bypass == true) {
2851
2852 //
2853 return true;
2854 }
2855
2856 // Si l'utilisateur est un intructeur qui ne correspond pas à la
2857 // division du dossier
2858 if ($this->f->isUserInstructeur()
2859 && $this->f->om_utilisateur["division"] != $this->getDivisionFromDossier()) {
2860
2861 //
2862 return false;
2863 }
2864
2865 // l'événement est-il le dernier ?
2866 $dernier_evenement = false;
2867 // instanciation dossier
2868 require_once "../obj/dossier.class.php";
2869 $dossier = new dossier($this->getVal('dossier'), $this->db, DEBUG);
2870 // récupération dernier événement
2871 $id_dernier_evenement = $dossier->get_dernier_evenement();
2872 if ($id_dernier_evenement == $this->getVal($this->clePrimaire)) {
2873 $dernier_evenement = true;
2874 }
2875
2876 // Si dossier cloturé ou si pas dernier événement
2877 // ou de type retour ou si une date est renseignée
2878 // ET utilisateur non administrateur
2879 if ($this->getStatutAutorisationDossier($this->getVal('dossier')) == 'cloture'
2880 || $dernier_evenement == false
2881 || $this->is_evenement_retour($this->getVal("evenement")) == true
2882 || $this->getVal('date_envoi_signature') != ''
2883 || $this->getVal('date_retour_signature') != ''
2884 || $this->getVal('date_envoi_rar') != ''
2885 || $this->getVal('date_retour_rar') != ''
2886 || $this->getVal('date_envoi_controle_legalite') != ''
2887 || $this->getVal('date_retour_controle_legalite') != '') {
2888 // pas le droit de supprimer
2889 return false;;
2890 }
2891
2892 //
2893 return true;
2894 }
2895
2896 /**
2897 * CONDITION - is_addable.
2898 *
2899 * Condition pour afficher les boutons modifier et supprimer.
2900 *
2901 * @return boolean
2902 */
2903 function is_addable() {
2904 // Contrôle si l'utilisateur possède un bypass
2905 $bypass = $this->f->isAccredited(get_class()."_ajouter_bypass");
2906 //
2907 if ($bypass == true) {
2908
2909 //
2910 return true;
2911 }
2912
2913 // Si l'utilisateur est un intructeur qui ne correspond pas à la
2914 // division du dossier
2915 if ($this->f->isUserInstructeur()
2916 && $this->f->om_utilisateur["division"] != $this->getDivisionFromDossier()
2917 && $this->f->isAccredited(array("instruction", "instruction_changer_decision"), "OR") === false) {
2918
2919 //
2920 return false;
2921 }
2922
2923 // si instructeur commune
2924 if($this->f->isAccredited(array("instruction", "instruction_changer_decision"), "OR") === false
2925 && $this->f->isInstrCanChangeDecision($this->getVal('dossier')) === true) {
2926 return false;
2927 }
2928
2929
2930 //
2931 return true;
2932 }
2933
2934 /**
2935 * CONDITION - is_finalizable.
2936 *
2937 * Condition pour afficher le bouton.
2938 *
2939 * @return boolean
2940 */
2941 function is_finalizable() {
2942 // Contrôle si l'utilisateur possède un bypass
2943 $bypass = $this->f->isAccredited(get_class()."_finaliser_bypass");
2944 //
2945 if ($bypass == true) {
2946
2947 //
2948 return true;
2949 }
2950
2951 // Si l'utilisateur est un intructeur qui ne correspond pas à la
2952 // division du dossier
2953 if ($this->f->isUserInstructeur()
2954 && $this->f->om_utilisateur["division"] != $this->getDivisionFromDossier()
2955 && $this->f->isAccredited(array("instruction", "instruction_changer_decision"), "OR") === false) {
2956
2957 //
2958 return false;
2959 }
2960
2961 // si instructeur commune
2962 if($this->f->isAccredited(array("instruction", "instruction_changer_decision"), "OR") === true
2963 && $this->f->om_utilisateur["division"] != $this->getDivisionFromDossier()
2964 && ($this->f->isInstrCanChangeDecision($this->getVal('dossier')) !== true
2965 || $this->getVal('created_by_commune') !== 't')) {
2966 return false;
2967 }
2968
2969 // Si l'utilisateur est un instructeur, que le dossier est cloturé et
2970 // que l'événement n'est pas identifié comme non verrouillable
2971 if ($this->f->isUserInstructeur()
2972 && $this->getStatutAutorisationDossier($this->getParameter("idxformulaire")) == "cloture"
2973 && $this->checkEvenementNonVerrouillable($this->getVal("instruction")) === false) {
2974
2975 //
2976 return false;
2977 }
2978
2979 //
2980 return true;
2981 }
2982
2983 /**
2984 * CONDITION - is_finalize_without_bypass.
2985 *
2986 * Condition pour afficher le bouton sans le bypass.
2987 *
2988 * @return boolean [description]
2989 */
2990 function is_finalizable_without_bypass() {
2991 // Récupère la valeur du champ finalisé
2992 $om_final_instruction = $this->getVal('om_final_instruction');
2993
2994 // Si le rapport n'est pas finalisé
2995 if (empty($om_final_instruction)
2996 || $om_final_instruction == 'f') {
2997 //
2998 return true;
2999 }
3000
3001 //
3002 return false;
3003 }
3004
3005 /**
3006 * CONDITION - is_unfinalizable.
3007 *
3008 * Condition pour afficher le bouton.
3009 *
3010 * @return boolean
3011 */
3012 function is_unfinalizable(){
3013 // Contrôle si l'utilisateur possède un bypass
3014 $bypass = $this->f->isAccredited(get_class()."_definaliser_bypass");
3015 //
3016 if ($bypass == true) {
3017
3018 //
3019 return true;
3020 }
3021
3022 // Si l'utilisateur est un intructeur qui ne correspond pas à la
3023 // division du dossier
3024 if ($this->f->isUserInstructeur()
3025 && $this->f->om_utilisateur["division"] != $this->getDivisionFromDossier()
3026 && $this->f->isAccredited(array("instruction", "instruction_changer_decision"), "OR") === false) {
3027
3028 //
3029 return false;
3030 }
3031
3032 // si instructeur commune
3033 if($this->f->isAccredited(array("instruction", "instruction_changer_decision"), "OR") === true
3034 && $this->f->om_utilisateur["division"] != $this->getDivisionFromDossier()
3035 && ($this->f->isInstrCanChangeDecision($this->getVal('dossier')) !== true
3036 || $this->getVal('created_by_commune') !== 't')) {
3037 return false;
3038 }
3039
3040 // Si l'utilisateur est un instructeur, que le dossier est cloturé et
3041 // que l'événement n'est pas identifié comme non verrouillable
3042 if ($this->f->isUserInstructeur()
3043 && $this->getStatutAutorisationDossier($this->getParameter("idxformulaire")) == "cloture"
3044 && $this->checkEvenementNonVerrouillable($this->getVal("instruction")) === false) {
3045
3046 //
3047 return false;
3048 }
3049
3050 //
3051 return true;
3052 }
3053
3054 /**
3055 * CONDITION - is_unfinalizable_without_bypass.
3056 *
3057 * Condition pour afficher le bouton sans le bypass.
3058 *
3059 * @return boolean
3060 */
3061 function is_unfinalizable_without_bypass() {
3062 // Récupère la valeur du champ finalisé
3063 $om_final_instruction = $this->getVal('om_final_instruction');
3064
3065 // Si l'instruction est finalisée
3066 if ($om_final_instruction == 't') {
3067 //
3068 return true;
3069 }
3070
3071 //
3072 return false;
3073 }
3074
3075
3076 /**
3077 * CONDITION - can_monitoring_dates.
3078 *
3079 * Condition pour afficher le bouton de suivi des dates.
3080 *
3081 * @return boolean
3082 */
3083 public function can_monitoring_dates() {
3084 // Récupère la valeur du champ finalisé
3085 $om_final_instruction = $this->getVal('om_final_instruction');
3086
3087 // Si l'instruction n'est pas finalisée
3088 if ($om_final_instruction !== 't') {
3089 //
3090 return false;
3091 }
3092
3093 // Contrôle si l'utilisateur possède un bypass
3094 $bypass = $this->f->isAccredited(get_class()."_modification_dates_bypass");
3095 if ($bypass === true) {
3096 return true;
3097 }
3098
3099 // On vérifie en premier lieu que le DI n'est pas clôturé
3100 $inst_dossier = $this->get_inst_dossier();
3101 if ($inst_dossier->getStatut() === 'cloture') {
3102 //
3103 return false;
3104 }
3105 // On récupère ses infos
3106 $coll_di = $inst_dossier->getVal('om_collectivite');
3107 $div_di = $this->getDivisionFromDossier();
3108 // et celles de son éventuel instructeur
3109 $instr_di = $inst_dossier->getVal('instructeur');
3110
3111 // Par défaut on prétend que l'instructeur n'est pas multi
3112 $instr_di_coll_multi = false;
3113 // Si un instructeur est affecté au dossier
3114 if ($instr_di !== '' && $instr_di !== null) {
3115 // Vérifie si l'instructeur est de la collectivité de niveau 2
3116 $instr_di_coll = $this->get_instructeur_om_collectivite($instr_di);
3117 if ($this->f->isCollectiviteMono($instr_di_coll) === false) {
3118 //
3119 $instr_di_coll_multi = true;
3120 }
3121 }
3122
3123 // S'il s'agit d'un instructeur
3124 if ($this->f->isUserInstructeur() === true) {
3125 // Il faut qu'il instruise le dossier ou soit de la même division
3126 if ($this->f->om_utilisateur['instructeur'] === $instr_di
3127 || $this->f->om_utilisateur['division'] === $div_di) {
3128 //
3129 return true;
3130 }
3131
3132 // On donne également le droit s'il est de la même collectivité que
3133 // le dossier et si l'instruction est déléguée à la communauté
3134 if ($this->f->isCollectiviteMono($this->f->om_utilisateur['om_collectivite']) === true
3135 && $this->f->om_utilisateur['om_collectivite'] === $coll_di
3136 && $instr_di_coll_multi === true) {
3137 //
3138 return true;
3139 }
3140
3141 // Si l'instructeur ne rentre pas dans les deux cas précédents
3142 return false;
3143 }
3144
3145 //
3146 // A ce stade l'utilisateur connecté n'est pas instructeur
3147 //
3148
3149 // Il a le droit s'il est de la communauté
3150 if ($this->f->isCollectiviteMono($this->f->om_utilisateur['om_collectivite']) === false) {
3151 //
3152 return true;
3153 }
3154
3155 // Sinon il faut qu'il soit de la même commune que celle du dossier
3156 if ($this->f->om_utilisateur['om_collectivite'] === $coll_di) {
3157 //
3158 return true;
3159 }
3160
3161 //
3162 return false;
3163 }
3164
3165
3166 /**
3167 * TREATMENT - finalize.
3168 *
3169 * Permet de finaliser un enregistrement.
3170 *
3171 * @param array $val valeurs soumises par le formulaire
3172 *
3173 * @return boolean
3174 */
3175 function finalize($val = array()) {
3176
3177 // Cette méthode permet d'exécuter une routine en début des méthodes
3178 // dites de TREATMENT.
3179 $this->begin_treatment(__METHOD__);
3180
3181 // Traitement de la finalisation
3182 $ret = $this->manage_finalizing("finalize", $val);
3183
3184 // Si le traitement retourne une erreur
3185 if ($ret !== true) {
3186
3187 // Termine le traitement
3188 return $this->end_treatment(__METHOD__, false);
3189 }
3190
3191 // Termine le traitement
3192 return $this->end_treatment(__METHOD__, true);
3193 }
3194
3195 /**
3196 * TREATMENT - unfinalize.
3197 *
3198 * Permet de définaliser un enregistrement.
3199 *
3200 * @param array $val valeurs soumises par le formulaire
3201 *
3202 * @return boolean
3203 */
3204 function unfinalize($val = array()) {
3205
3206 // Cette méthode permet d'exécuter une routine en début des méthodes
3207 // dites de TREATMENT.
3208 $this->begin_treatment(__METHOD__);
3209
3210 // Traitement de la finalisation
3211 $ret = $this->manage_finalizing("unfinalize", $val);
3212
3213 // Si le traitement retourne une erreur
3214 if ($ret !== true) {
3215
3216 // Termine le traitement
3217 return $this->end_treatment(__METHOD__, false);
3218 }
3219
3220 // Termine le traitement
3221 return $this->end_treatment(__METHOD__, true);
3222 }
3223
3224 /**
3225 * VIEW - view_edition
3226 *
3227 * Edite l'édition de l'instruction ou affiche celle contenue dans le stockage.
3228 *
3229 * @return null Si l'action est incorrecte
3230 */
3231 function view_edition() {
3232
3233 // Si l'instruction est finalisée
3234 if($this->getVal("om_final_instruction") == 't'
3235 && $this->getVal("om_final_instruction") != null) {
3236
3237 // Ouvre le document
3238 $lien = '../spg/file.php?obj='.$this->table.'&'.
3239 'champ=om_fichier_instruction&id='.$this->getVal($this->clePrimaire);
3240 //
3241 header("Location: ".$lien);
3242 } else {
3243
3244 // Récupère la collectivite du dossier d'instruction
3245 $dossier_instruction_om_collectivite = $this->get_dossier_instruction_om_collectivite();
3246
3247 //
3248 $collectivite = $this->f->getCollectivite($dossier_instruction_om_collectivite);
3249
3250 // Paramètre du PDF
3251 $params = array(
3252 "watermark" => true,
3253 "specific" => array(
3254 "mode" => "previsualisation",
3255 ),
3256 );
3257
3258 // Génération du PDF
3259 $result = $this->compute_pdf_output('lettretype', $this->getVal("lettretype"), $collectivite, null, $params);
3260 // Affichage du PDF
3261 $this->expose_pdf_output(
3262 $result['pdf_output'],
3263 $result['filename']
3264 );
3265 }
3266 }
3267
3268 /**
3269 * Récupère la collectivité du dossier d'instruction.
3270 *
3271 * @return integer
3272 */
3273 function get_dossier_instruction_om_collectivite() {
3274
3275 //
3276 require_once "../obj/dossier_instruction.class.php";
3277 $dossier_instruction = new dossier_instruction($this->getVal('dossier'), $this->f->db, false);
3278
3279 //
3280 return $dossier_instruction->getVal('om_collectivite');
3281 }
3282
3283 /**
3284 * VIEW - view_bible
3285 *
3286 * Affiche la bible manuelle.
3287 *
3288 * @return void
3289 */
3290 function view_bible() {
3291 // Vérification de l'accessibilité sur l'élément
3292 $this->checkAccessibility();
3293
3294 // XXX APP
3295
3296 $f = $this->f;
3297
3298 /**
3299 * Affichage de la structure HTML
3300 */
3301 //
3302 if ($f->isAjaxRequest()) {
3303 //
3304 header("Content-type: text/html; charset=".HTTPCHARSET."");
3305 } else {
3306 //
3307 $f->setFlag("htmlonly");
3308 $f->display();
3309 }
3310 //
3311 $f->displayStartContent();
3312 //
3313 $f->setTitle(_("Liste des éléments de la bible en lien avec un evenement"));
3314 $f->displayTitle();
3315
3316 /**
3317 *
3318 */
3319 //
3320 ($f->get_submitted_get_value("ev") ? $evenement = $f->get_submitted_get_value("ev") : $evenement = "");
3321 $evenement = intval($evenement);
3322 //
3323 ($f->get_submitted_get_value("idx") ? $idx = $f->get_submitted_get_value("idx") : $idx = "");
3324 // Récupération du code du type de DA
3325 $code_da_type = '';
3326 if (preg_match('/[A-Za-z]{2,3}/', $idx, $matches) !== false) {
3327 $code_da_type = $matches[0];
3328 }
3329 //
3330 ($f->get_submitted_get_value("complement") ? $complement = $f->get_submitted_get_value("complement") : $complement = "1");
3331
3332 // Récupération de la collectivité du dossier
3333 require_once "../obj/dossier.class.php";
3334 $dossier = new dossier($idx, $f->db, DEBUG);
3335
3336 /**
3337 *
3338 */
3339 //
3340 $sql = "SELECT *, bible.libelle as bible_lib
3341 FROM ".DB_PREFIXE."bible
3342 LEFT OUTER JOIN ".DB_PREFIXE."dossier_autorisation_type
3343 ON bible.dossier_autorisation_type=dossier_autorisation_type.dossier_autorisation_type
3344 LEFT JOIN ".DB_PREFIXE."om_collectivite
3345 ON bible.om_collectivite = om_collectivite.om_collectivite
3346 WHERE evenement=".$evenement."
3347 AND complement=".$complement."
3348 AND (bible.dossier_autorisation_type IS NULL
3349 OR dossier_autorisation_type.code ='".$code_da_type."')
3350 AND (om_collectivite.niveau = '2'
3351 OR bible.om_collectivite = ".$dossier->getVal("om_collectivite").")
3352 ORDER BY bible_lib ASC";
3353 $res = $f->db->query($sql);
3354 $f->addToLog(__METHOD__.": db->query(\"".$sql."\");", VERBOSE_MODE);
3355 $f->isDatabaseError($res);
3356 //
3357 echo "<form method=\"post\" name=\"f3\" action=\"#\">\n";
3358 //
3359 if ($res->numrows() > 0) {
3360 //
3361 echo "\t<table id='tab-bible' width='100%'>\n";
3362 //
3363 echo "\t\t<tr class=\"ui-tabs-nav ui-accordion ui-state-default tab-title\">";
3364 echo "<th>"._("Choisir")."</th>";
3365 echo "<th>"._("Libelle")."</th>";
3366 echo "</tr>\n";
3367 //
3368 $i = 0;
3369 //
3370 while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
3371 //
3372 echo "\t\t<tr";
3373 echo " class=\"".($i % 2 == 0 ? "odd" : "even")."\"";
3374 echo ">";
3375 //
3376 echo "<td class=\"center\"><input type=\"checkbox\" name=\"choix[]\" value=\"".$i."\" id=\"checkbox".$i."\" /></td>";
3377 // XXX utilisation de l'attribut titre pour afficher une infobulle
3378 echo "<td><span class=\"content\" title=\"".htmlentities($row['contenu'])."\" id=\"content".$i."\">".$row['bible_lib']."</span></td>";
3379 //
3380 echo "</tr>\n";
3381 //
3382 $i++;
3383 }
3384 echo "\t</table>\n";
3385 //
3386 echo "<div class=\"formControls\">\n";
3387 $f->layout->display_form_button(array(
3388 "value" => _("Valider"),
3389 "onclick" => "bible_return('f2', 'complement".($complement == "1" ? "" : $complement)."_om_html'); return false;",
3390 ));
3391 $f->displayLinkJsCloseWindow();
3392 echo "</div>\n";
3393
3394 } else {
3395 //
3396 $message_class = "error";
3397 $message = _("Aucun element dans la bible pour l'evenement")." : ".$evenement;
3398 $f->displayMessage($message_class, $message);
3399 //
3400 echo "<div class=\"formControls\">\n";
3401 $f->displayLinkJsCloseWindow();
3402 echo "</div>\n";
3403 }
3404 //
3405 echo "</form>\n";
3406
3407 /**
3408 * Affichage de la structure HTML
3409 */
3410 //
3411 $f->displayEndContent();
3412 }
3413
3414 /**
3415 * VIEW - view_bible_auto
3416 *
3417 * Renvoie les valeurs de la bible à placer dans les compléments de l'instruction.
3418 *
3419 * @return void
3420 */
3421 function view_bible_auto() {
3422 // Vérification de l'accessibilité sur l'élément
3423 $this->checkAccessibility();
3424
3425 // XXX APP
3426
3427 $f = $this->f;
3428
3429 //
3430 $f->disableLog();
3431
3432 $formatDate="AAAA-MM-JJ";
3433
3434 // Récupération des paramètres
3435 $idx = $f->get_submitted_get_value('idx');
3436 $evenement = $f->get_submitted_get_value('ev');
3437
3438 // Initialisation de la variable de retour
3439 $retour['complement_om_html'] = '';
3440 $retour['complement2_om_html'] = '';
3441 $retour['complement3_om_html'] = '';
3442 $retour['complement4_om_html'] = '';
3443 // Vérification d'une consultation liée à l'événement
3444 $consultation = $f->db->getOne(
3445 "select consultation from ".DB_PREFIXE."evenement where evenement=".$evenement
3446 );
3447 $f->isDatabaseError($consultation);
3448 // Si consultation liée, récupération du retour d'avis
3449 if($consultation=='Oui'){
3450 $sql="select date_retour,avis_consultation.libelle as avis_consultation,
3451 service.libelle as service
3452 from ".DB_PREFIXE."consultation inner join ".DB_PREFIXE."service
3453 on consultation.service =service.service
3454 left join ".DB_PREFIXE."avis_consultation on
3455 consultation.avis_consultation = avis_consultation.avis_consultation
3456 where dossier ='".$idx."'";
3457 $res = $f->db->query($sql);
3458 $f->isDatabaseError($res);
3459 // Récupération des consultations
3460 while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)){
3461 $correct=false;
3462 // date retour
3463 if ($row['date_retour']<>""){
3464 if ($formatDate=="AAAA-MM-JJ"){
3465 $date = explode("-", $row['date_retour']);
3466 // controle de date
3467 if (count($date) == 3 and
3468 checkdate($date[1], $date[2], $date[0])) {
3469 $date_retour_f= $date[2]."/".$date[1]."/".$date[0];
3470 $correct=true;
3471 }else{
3472 $msg= $msg."<br>La date ".$row['date_retour']." n'est pas une date.";
3473 $correct=false;
3474 }
3475 }
3476 }
3477 //
3478 $temp="Vu l'avis ".$row['avis_consultation']." du service ".$row['service'];
3479 if($correct == true){
3480 $temp=$temp." du ".$date_retour_f;
3481 }
3482 // Concaténation des retours d'avis de consultation
3483 $retour['complement_om_html'] .= $temp;
3484 } // while
3485
3486 } // consultation
3487 // Récupération des bibles automatiques pour le champ complement_om_html
3488 $retour['complement_om_html'] .= $this->getBible($f, $evenement, $idx, '1');
3489 // Récupération des bibles automatiques pour le champ complement2_om_html
3490 $retour['complement2_om_html'] .= $this->getBible($f, $evenement, $idx, '2');
3491 // Récupération des bibles automatiques pour le champ complement3_om_html
3492 $retour['complement3_om_html'] .= $this->getBible($f, $evenement, $idx, '3');
3493 // Récupération des bibles automatiques pour le champ complement4_om_html
3494 $retour['complement4_om_html'] .= $this->getBible($f, $evenement, $idx, '4');
3495
3496
3497
3498 echo json_encode($retour);
3499 }
3500
3501 /**
3502 * Récupération des éléments de bible.
3503 *
3504 * @param utils $f handler de om_application
3505 * @param integer $event id de l'événement
3506 * @param string $idx id du dossier
3507 * @param integer $compnb numéro du champ complement
3508 *
3509 * @return string Chaîne de texte à insérer dans le champ complement
3510 */
3511 function getBible($f, $event, $idx, $compnb) {
3512 // Récupération de la collectivité du dossier
3513 require_once "../obj/dossier.class.php";
3514 $dossier = new dossier($idx, $f->db, DEBUG);
3515 // Récupération du code du type de DA
3516 $code_da_type = '';
3517 if (preg_match('/[A-Za-z]{2,3}/', $idx, $matches) !== false) {
3518 $code_da_type = $matches[0];
3519 }
3520 //
3521 $sql = "SELECT * FROM ".DB_PREFIXE."bible
3522 LEFT OUTER JOIN ".DB_PREFIXE."dossier_autorisation_type
3523 ON bible.dossier_autorisation_type=
3524 dossier_autorisation_type.dossier_autorisation_type
3525 LEFT JOIN
3526 ".DB_PREFIXE."om_collectivite
3527 ON bible.om_collectivite = om_collectivite.om_collectivite
3528 WHERE evenement =".$event." and
3529 complement=".$compnb." and
3530 automatique='Oui' and
3531 (dossier_autorisation_type.code ='".$code_da_type."' or
3532 bible.dossier_autorisation_type IS NULL) and
3533 (om_collectivite.niveau = '2' OR bible.om_collectivite = ".$dossier->getVal("om_collectivite").")";
3534
3535 $res = $f->db->query($sql);
3536 $f->isDatabaseError($res);
3537 $temp = "";
3538 while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)){
3539 // Remplacement des retours à la ligne par des br
3540 $temp .= preg_replace(
3541 '#(\\\r|\\\r\\\n|\\\n)#', '<br/>', $row['contenu']
3542 );
3543 } // fin while
3544 return $temp;
3545 }
3546
3547 /**
3548 * VIEW - view_suivi_bordereaux.
3549 *
3550 * Formulaire de choix du bordereau de suivi, permettant de générer les 4 bordereaux.
3551 * Si l'utilisateur est d'une collectivité de niveau 2 il a le choix de la
3552 * collectivité des dossiers affichés.
3553 *
3554 * @return void
3555 */
3556 function view_suivi_bordereaux() {
3557 // Vérification de l'accessibilité sur l'élément
3558 $this->checkAccessibility();
3559
3560 // XXX APP
3561
3562 $f = $this->f;
3563
3564 /**
3565 * Validation du formulaire
3566 */
3567 // Si le formulaire a été validé
3568 if ($f->get_submitted_post_value("validation") !== null) {
3569 // Si un bordereau à été sélectionné
3570 if ($f->get_submitted_post_value("bordereau") !== null && $f->get_submitted_post_value("bordereau") == "" ) {
3571 // Si aucun bordereau n'a été sélectionné
3572 $message_class = "error";
3573 $message = _("Veuillez selectionner un bordereau.");
3574 }
3575 // Sinon si les dates ne sont pas valide
3576 elseif (($f->get_submitted_post_value("date_bordereau_debut") !== null
3577 && $f->get_submitted_post_value("date_bordereau_debut") == "")
3578 || ($f->get_submitted_post_value("date_bordereau_fin") !== null
3579 && $f->get_submitted_post_value("date_bordereau_fin") == "")) {
3580 // Si aucune date n'a été saisie
3581 $message_class = "error";
3582 $message = _("Veuillez saisir une date valide.");
3583 }
3584 // Affiche le message de validation
3585 else {
3586 // On récupère le libellé du bordereau pour l'afficher à l'utilisateur
3587 $sql = "SELECT om_etat.libelle
3588 FROM ".DB_PREFIXE."om_etat
3589 WHERE om_etat.id = '".$f->get_submitted_post_value("bordereau")."'";
3590 $res = $f->db->getone($sql);
3591 $f->addToLog(__METHOD__.": db->getone(\"".$sql."\")", VERBOSE_MODE);
3592 $f->isDatabaseError($res);
3593 //
3594 $message_class = "valid";
3595 $message = _("Cliquez sur le lien ci-dessous pour telecharger votre bordereau");
3596 $message .= " : <br/><br/>";
3597 $message .= "<a class='om-prev-icon pdf-16'";
3598 $message .= " title=\""._("Bordereau")."\"";
3599 $message .= "href='../scr/form.php?obj=instruction";
3600 $message .= "&action=220";
3601 $message .= "&idx=0";
3602 $message .= "&type_bordereau=".$f->get_submitted_post_value("bordereau");
3603 $message .= "&date_bordereau_debut=".$f->get_submitted_post_value("date_bordereau_debut");
3604 $message .= "&date_bordereau_fin=".$f->get_submitted_post_value("date_bordereau_fin");
3605 // Si l'utilisateur est MULTI alors on ajoute le paramètre collectivite
3606 if ($f->get_submitted_post_value("om_collectivite") !== null) {
3607 $message .= "&collectivite=".$f->get_submitted_post_value("om_collectivite");
3608 }
3609 $message .= "'"." target='_blank'>";
3610 $message .= $res." "._("du")." ".$f->get_submitted_post_value("date_bordereau_debut")
3611 ." "._("au")." ".$f->get_submitted_post_value("date_bordereau_fin");
3612 $message .= "</a>";
3613 }
3614 }
3615
3616 /**
3617 * Affichage des messages et du formulaire
3618 */
3619 // Affichage du message de validation ou d'erreur
3620 if (isset($message) && isset($message_class) && $message != "") {
3621 $f->displayMessage($message_class, $message);
3622 }
3623 // Inclusion de la classe de gestion des formulaires
3624 require_once "../obj/om_formulaire.class.php";
3625 // Ouverture du formulaire
3626 printf("\t<form");
3627 printf(" method=\"post\"");
3628 printf(" id=\"suivi_bordereaux_form\"");
3629 printf(" action=\"\"");
3630 printf(">\n");
3631 // Paramétrage des champs du formulaire
3632 $champs = array("date_bordereau_debut", "date_bordereau_fin", "bordereau");
3633 // Si l'utilisateur est d'une collectivité de niveau 2 on affiche un select
3634 // collectivité dans le formulaire
3635 if($_SESSION["niveau"] == 2) {
3636 array_push($champs, "om_collectivite");
3637 }
3638 // Création d'un nouvel objet de type formulaire
3639 $form = new formulaire(NULL, 0, 0, $champs);
3640 // Paramétrage du champ date_bordereau_debut
3641 $form->setLib("date_bordereau_debut", _("date_bordereau_debut"));
3642 $form->setType("date_bordereau_debut", "date");
3643 $form->setTaille("date_bordereau_debut", 12);
3644 $form->setMax("date_bordereau_debut", 12);
3645 $form->setRequired("date_bordereau_debut");
3646 $form->setOnchange("date_bordereau_debut", "fdate(this)");
3647 $form->setVal("date_bordereau_debut", date("d/m/Y"));
3648 // Paramétrage du champ date_bordereau_fin
3649 $form->setLib("date_bordereau_fin", _("date_bordereau_fin"));
3650 $form->setType("date_bordereau_fin", "date");
3651 $form->setTaille("date_bordereau_fin", 12);
3652 $form->setMax("date_bordereau_fin", 12);
3653 $form->setRequired("date_bordereau_fin");
3654 $form->setOnchange("date_bordereau_fin", "fdate(this)");
3655 $form->setVal("date_bordereau_fin", date("d/m/Y"));
3656 // Paramétrage du champ bordereau
3657 $form->setLib("bordereau", _("bordereau"));
3658 $form->setType("bordereau", "select");
3659 $form->setRequired("bordereau");
3660 // Valeurs des champs
3661 if ($f->get_submitted_post_value("validation") !== null) {
3662 $form->setVal("date_bordereau_debut", $f->get_submitted_post_value("date_bordereau_debut"));
3663 $form->setVal("date_bordereau_fin", $f->get_submitted_post_value("date_bordereau_fin"));
3664 $form->setVal("bordereau", $f->get_submitted_post_value("bordereau"));
3665 $form->setVal("om_collectivite", $f->get_submitted_post_value("om_collectivite"));
3666 }
3667 // Données du select - On récupère ici la liste de tous les états disponibles
3668 // dans la table om_etat qui ont un id qui commence par la cahine de caractères
3669 // 'bordereau_'
3670 $sql = "SELECT om_etat.id, om_etat.libelle
3671 FROM ".DB_PREFIXE."om_etat
3672 WHERE om_etat.id LIKE 'bordereau_%'
3673 ORDER BY om_etat.id";
3674 $res = $f->db->query($sql);
3675 $f->addToLog(__METHOD__.": db->query(\"".$sql."\")", VERBOSE_MODE);
3676 $f->isDatabaseError($res);
3677 // Données du select
3678 $contenu = array(
3679 0 => array("", ),
3680 1 => array(_("choisir bordereau")),
3681 );
3682 while ($row =& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
3683 $contenu[0][] = $row['id'];
3684 $contenu[1][] = $row['libelle'];
3685 }
3686 $form->setSelect("bordereau", $contenu);
3687 //
3688 if($_SESSION["niveau"] == 2) {
3689 $form->setLib("om_collectivite", _("collectivite"));
3690 $form->setType("om_collectivite", "select");
3691
3692 // Données du select - On récupère ici la liste de tous toutes les collectivités
3693 // de niveau 1
3694 $sql = "SELECT om_collectivite, libelle
3695 FROM ".DB_PREFIXE."om_collectivite
3696 WHERE niveau = '1' ORDER BY libelle";
3697 $res = $f->db->query($sql);
3698 $f->addToLog(__METHOD__.": db->query(\"".$sql."\")", VERBOSE_MODE);
3699 $f->isDatabaseError($res);
3700 // La valeur par défaut du select est Toutes
3701 $list_collectivites = array(
3702 0 => array("", ),
3703 1 => array(_("toutes"))
3704 );
3705
3706 $id_colls = "";
3707 // On stocke dans $id_colls l'id de toutes les collectivités de niveau 1 séparées
3708 // par des virgules, pour un traitement plus facile dans la requête de sous-état
3709 while ($row =& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
3710 if ($id_colls != "") {
3711 $id_colls .= ",";
3712 }
3713 $id_colls .= $row['om_collectivite'];
3714 $list_collectivites[0][] = $row['om_collectivite'];
3715 $list_collectivites[1][] = $row['libelle'];
3716 }
3717 // On affecte la liste d'identifiants à l'option Toutes
3718 $list_collectivites[0][0] = $id_colls ;
3719 $form->setSelect("om_collectivite", $list_collectivites);
3720 }
3721
3722 // Affichage du formulaire
3723 $form->entete();
3724 $form->afficher($champs, 0, false, false);
3725 $form->enpied();
3726 // Affichage du bouton
3727 printf("\t<div class=\"formControls\">\n");
3728 $f->layout->display_form_button(array("value" => _("Valider"), "name" => "validation"));
3729 printf("\t</div>\n");
3730 // Fermeture du formulaire
3731 printf("\t</form>\n");
3732
3733 }
3734
3735
3736 /**
3737 * VIEW - view_generate_suivi_bordereaux.
3738 *
3739 * Génère et affiche les bordereaux de suivi.
3740 *
3741 * @return [void]
3742 */
3743 function view_generate_suivi_bordereaux() {
3744 // Vérification de l'accessibilité sur l'élément
3745 $this->checkAccessibility();
3746 // Récupération du type de bordereau
3747 $bordereau = $this->f->get_submitted_get_value('type_bordereau');
3748 // Génération du PDF
3749 $result = $this->compute_pdf_output('etat', $bordereau, null, $this->getVal($this->clePrimaire));
3750 // Affichage du PDF
3751 $this->expose_pdf_output(
3752 $result['pdf_output'],
3753 $result['filename']
3754 );
3755 }
3756
3757
3758 /**
3759 * VIEW - view_suivi_envoi_lettre_rar.
3760 *
3761 * Vu pour imprimer les RAR.
3762 *
3763 * @return void
3764 */
3765 function view_suivi_envoi_lettre_rar() {
3766 // Vérification de l'accessibilité sur l'élément
3767 $this->checkAccessibility();
3768
3769 // XXX APP
3770
3771 $f = $this->f;
3772
3773 //
3774 if ($f->get_submitted_post_value("date") !== null) {
3775 $date = $f->get_submitted_post_value("date");
3776 } else {
3777 $date = "";
3778 }
3779 //
3780 if ($f->get_submitted_post_value("liste_code_barres_instruction") !== null) {
3781 $liste_code_barres_instruction = $f->get_submitted_post_value("liste_code_barres_instruction");
3782 } else {
3783 $liste_code_barres_instruction = "";
3784 }
3785
3786 // Compteur du nombre de page générées
3787 $nbLettres = 0;
3788 // Liste d'id des instructions
3789 $id4Gen = array();
3790 //
3791 $error = "";
3792
3793 /**
3794 * Validation du formulaire
3795 */
3796 // Si le formulaire a été validé
3797 if ($f->get_submitted_post_value('validation') !== null) {
3798 //
3799 if (empty($date) || empty($liste_code_barres_instruction)) {
3800 //
3801 $message_class = "error";
3802 $message = _("Tous les champs doivent etre remplis.");
3803 } else {
3804 // Création d'un tableau d'instruction
3805 $liste = explode("\r\n", $f->get_submitted_post_value("liste_code_barres_instruction"));
3806 //
3807 foreach ($liste as $code_barres) {
3808 // On enlève les éventuels espaces saisis
3809 $code_barres = trim($code_barres);
3810 // Vérification de l'existence de l'instruction
3811 if ($code_barres != "") {
3812 // Si la valeur transmise est numérique
3813 if (is_numeric($code_barres)) {
3814 //
3815 $sql = "SELECT count(*) FROM ".DB_PREFIXE."instruction WHERE code_barres='".$code_barres."'";
3816 $nbInstr = $f->db->getone($sql);
3817 $f->addToLog(__METHOD__.": db->getone(\"".$sql."\")", VERBOSE_MODE);
3818 $f->isDatabaseError($nbInstr);
3819 //
3820 if ($nbInstr == "1") {
3821 // Récupération de la date d'envoi de l'instruction bippé
3822 $sql = "SELECT to_char(date_envoi_rar,'DD/MM/YYYY') as date_envoi_rar, instruction FROM ".DB_PREFIXE."instruction WHERE code_barres='".$code_barres."'";
3823 $res = $f->db->query($sql);
3824 $f->addToLog(__METHOD__.": db->query(\"".$sql."\")", VERBOSE_MODE);
3825 $f->isDatabaseError($res);
3826 $row =& $res->fetchRow(DB_FETCHMODE_ASSOC);
3827 // Si pas de date ou correspond à la date du formulaire on
3828 // effectue le traitement
3829 if ($row["date_envoi_rar"] == "" || $row["date_envoi_rar"] == $date) {
3830
3831 require_once '../obj/instruction.class.php';
3832
3833 $instr = new instruction($row['instruction'], $f->db, DEBUG);
3834 $valF = array();
3835 foreach($instr->champs as $id => $champ) {
3836 $valF[$champ] = $instr->val[$id];
3837 }
3838 $valF['date_evenement']=
3839 $instr->dateDBToForm($valF['date_evenement']);
3840 $valF['archive_date_complet']=
3841 $instr->dateDBToForm($valF['archive_date_complet']);
3842 $valF['archive_date_rejet']=
3843 $instr->dateDBToForm($valF['archive_date_rejet']);
3844 $valF['archive_date_limite']=
3845 $instr->dateDBToForm($valF['archive_date_limite']);
3846 $valF['archive_date_notification_delai']=
3847 $instr->dateDBToForm($valF['archive_date_notification_delai']);
3848 $valF['archive_date_decision']=
3849 $instr->dateDBToForm($valF['archive_date_decision']);
3850 $valF['archive_date_validite']=
3851 $instr->dateDBToForm($valF['archive_date_validite']);
3852 $valF['archive_date_achevement']=
3853 $instr->dateDBToForm($valF['archive_date_achevement']);
3854 $valF['archive_date_chantier']=
3855 $instr->dateDBToForm($valF['archive_date_chantier']);
3856 $valF['archive_date_conformite']=
3857 $instr->dateDBToForm($valF['archive_date_conformite']);
3858 $valF['archive_date_dernier_depot']=
3859 $instr->dateDBToForm($valF['archive_date_dernier_depot']);
3860 $valF['archive_date_limite_incompletude']=
3861 $instr->dateDBToForm($valF['archive_date_limite_incompletude']);
3862 $valF['date_finalisation_courrier']=
3863 $instr->dateDBToForm($valF['date_finalisation_courrier']);
3864 $valF['date_envoi_signature']=
3865 $instr->dateDBToForm($valF['date_envoi_signature']);
3866 $valF['date_retour_signature']=
3867 $instr->dateDBToForm($valF['date_retour_signature']);
3868 $valF['date_envoi_rar']=
3869 $instr->dateDBToForm($valF['date_envoi_rar']);
3870 $valF['date_retour_rar']=
3871 $instr->dateDBToForm($valF['date_retour_rar']);
3872 $valF['date_envoi_controle_legalite']=
3873 $instr->dateDBToForm($valF['date_envoi_controle_legalite']);
3874 $valF['date_retour_controle_legalite']=
3875 $instr->dateDBToForm($valF['date_retour_controle_legalite']);
3876
3877 $valF['date_envoi_rar'] = $date;
3878
3879 // Vérification de la finalisation du document
3880 // correspondant au code barres
3881 if($instr->getVal("om_final_instruction") === 't') {
3882 $instr->setParameter('maj', 1);
3883 $instr->class_actions[1]["identifier"] =
3884 "envoi lettre RAR (depuis le menu suivi des pièces)";
3885 if ($instr->modifier($valF, $f->db, DEBUG) == true) {
3886 $id4Gen[] = $code_barres;
3887 $nbLettres ++;
3888 } else {
3889 //
3890 if ($error != "") {
3891 $error .= "<br/>";
3892 }
3893 $error .= sprintf(_("Une erreur s'est produite lors de la modification de l'instruction %s."),
3894 $code_barres);
3895 $error .= " ";
3896 $error .= _("Veuillez contacter votre administrateur.");
3897 }
3898 } else {
3899 //
3900 if ($error != "") {
3901 $error .= "<br/>";
3902 }
3903 $error .= sprintf(_("Le document correspondant au
3904 code barres %s n'est pas finalise,
3905 le bordereau ne sera pas genere."),
3906 $code_barres);
3907 }
3908
3909 } else {
3910 //
3911 if ($error != "") {
3912 $error .= "<br/>";
3913 }
3914 $error .= _("Une lettre correspondante a l'instruction ayant pour code barres")." ".$code_barres." "._("a deja ete envoyee, le bordereau ne sera pas genere.");
3915 }
3916 } else {
3917 //
3918 if ($error != "") {
3919 $error .= "<br/>";
3920 }
3921 $error .= _("Le numero")." ".$code_barres." "._("ne correspond a aucun code barres d'instruction.");
3922 }
3923 } else {
3924 //
3925 if ($error != "") {
3926 $error .= "<br/>";
3927 }
3928 $error .= _("Le code barres d'instruction")." ".$code_barres." "._("n'est pas valide.");
3929 }
3930 }
3931 }
3932 }
3933 }
3934
3935 /**
3936 * Affichage des messages et du formulaire
3937 */
3938 // Affichage du message de validation ou d'erreur
3939 if (isset($message) && isset($message_class) && $message != "") {
3940 $f->displayMessage($message_class, $message);
3941 }
3942 // Affichage du message d'erreur
3943 if(!empty($error)) {
3944 $f->displayMessage("error", $error);
3945 }
3946 // Affichage du message de validation de la saisie
3947 if ($nbLettres > 0) {
3948 //
3949 $message_class = "valid";
3950 $message = _("Cliquez sur le lien ci-dessous pour telecharger votre document");
3951 $message .= " : <br/><br/>";
3952 $message .= "<a class='om-prev-icon pdf-16'";
3953 $message .= " title=\""._("imprimer les RAR")."\"";
3954 $message .= " href=\"../scr/form.php?obj=instruction&action=180&idx=0&liste=".implode(",",$id4Gen)."\"";
3955 $message .= " target='_blank'>";
3956 $message .= _("Telecharger le document pour")." ".$nbLettres." "._("RAR");
3957 $message .= "</a>";
3958 $f->displayMessage($message_class, $message);
3959 }
3960 // Inclusion de la classe de gestion des formulaires
3961 require_once "../obj/om_formulaire.class.php";
3962 // Ouverture du formulaire
3963 echo "\t<form";
3964 echo " method=\"post\"";
3965 echo " id=\"suivi_envoi_lettre_rar_form\"";
3966 echo " action=\"\"";
3967 echo ">\n";
3968 // Paramétrage des champs du formulaire
3969 $champs = array("date", "liste_code_barres_instruction");
3970 // Création d'un nouvel objet de type formulaire
3971 $form = new formulaire(NULL, 0, 0, $champs);
3972 // Paramétrage du champ date du formulaire
3973 $form->setLib("date", _("Date")."* :");
3974 $form->setType("date", "date");
3975 $form->setOnchange("date", "fdate(this)");
3976 $form->setVal("date", ($date == "" ? date("d/m/Y") : $date));
3977 $form->setTaille("date", 10);
3978 $form->setMax("date", 10);
3979 // Paramétrage du champ liste_code_barres_instruction du formulaire
3980 $form->setLib("liste_code_barres_instruction", _("Liste des codes barres d'instructions scannes")."* :");
3981 $form->setType("liste_code_barres_instruction", "textarea");
3982 $form->setVal("liste_code_barres_instruction", $liste_code_barres_instruction);
3983 $form->setTaille("liste_code_barres_instruction", 20);
3984 $form->setMax("liste_code_barres_instruction", 20);
3985 // Affichage du formulaire
3986 $form->entete();
3987 $form->afficher($champs, 0, false, false);
3988 $form->enpied();
3989 // Affichage du bouton
3990 echo "\t<div class=\"formControls\">\n";
3991 $f->layout->display_form_button(array("value" => _("Valider"), "name" => "validation"));
3992 echo "\t</div>\n";
3993 // Fermeture du formulaire
3994 echo "\t</form>\n";
3995 }
3996
3997 /**
3998 * VIEW - view_suivi_mise_a_jour_des_dates.
3999 *
4000 * Vu pour mettre à jour les dates de suivi de l'instruction.
4001 *
4002 * @return void
4003 */
4004 function view_suivi_mise_a_jour_des_dates() {
4005 // Vérification de l'accessibilité sur l'élément
4006 $this->checkAccessibility();
4007
4008 // XXX APP
4009
4010 $f = $this->f;
4011
4012 // Récupération des valeur passées en POST ou GET
4013 if($f->get_submitted_post_value("type_mise_a_jour") !== null) {
4014 $type_mise_a_jour = $f->get_submitted_post_value("type_mise_a_jour");
4015 } elseif($f->get_submitted_get_value('type_mise_a_jour') !== null) {
4016 $type_mise_a_jour = $f->get_submitted_get_value('type_mise_a_jour');
4017 } else {
4018 $type_mise_a_jour = "";
4019 }
4020 if($f->get_submitted_post_value('date') !== null) {
4021 $date = $f->get_submitted_post_value('date');
4022 } elseif($f->get_submitted_get_value('date') !== null) {
4023 $date = $f->get_submitted_get_value('date');
4024 } else {
4025 $date = "";
4026 }
4027 if($f->get_submitted_post_value('code_barres') !== null) {
4028 $code_barres = $f->get_submitted_post_value('code_barres');
4029 } elseif($f->get_submitted_get_value('code_barres') !== null) {
4030 $code_barres = $f->get_submitted_get_value('code_barres');
4031 } else {
4032 $code_barres = "";
4033 }
4034 // Booléen permettant de définir si un enregistrement à eu lieu
4035 $correct = false;
4036 // Booléen permettant de définir si les dates peuvent êtres enregistrées
4037 $date_error = false;
4038 // Champs date à mettre à jour
4039 $liste_champs=array();
4040
4041 // Si le formulaire a été validé
4042 if ($f->get_submitted_post_value('validation') !== null) {
4043 if(!empty($type_mise_a_jour) and !empty($date) and !empty($code_barres)) {
4044
4045 //Vérification de l'existance de l'instruction
4046 $sql = "SELECT instruction FROM ".DB_PREFIXE."instruction WHERE code_barres='".$this->f->db->escapesimple($code_barres)."'";
4047 $res = $f->db->query($sql);
4048 $f->addToLog(__METHOD__.": db->query(\"".$sql."\")", VERBOSE_MODE);
4049 $f->isDatabaseError($res);
4050
4051 if($res->numrows() == 1) {
4052 $liste_champs = explode(";", $type_mise_a_jour);
4053 // Mise à jour des dates après l'écran de verification
4054 if($f->get_submitted_post_value('is_valid') !== null and $f->get_submitted_post_value('is_valid') == "true") {
4055 require_once '../obj/instruction.class.php';
4056 $row =& $res->fetchRow(DB_FETCHMODE_ASSOC);
4057 $instr = new instruction($row['instruction'], $f->db, DEBUG);
4058 $valF = array();
4059 foreach($instr->champs as $id => $champ) {
4060 $valF[$champ] = $instr->val[$id];
4061 }
4062 $valF['date_evenement']=$instr->dateDBToForm($valF['date_evenement']);
4063 $valF['archive_date_complet']=$instr->dateDBToForm($valF['archive_date_complet']);
4064 $valF['archive_date_rejet']=$instr->dateDBToForm($valF['archive_date_rejet']);
4065 $valF['archive_date_limite']=$instr->dateDBToForm($valF['archive_date_limite']);
4066 $valF['archive_date_notification_delai']=$instr->dateDBToForm($valF['archive_date_notification_delai']);
4067 $valF['archive_date_decision']=$instr->dateDBToForm($valF['archive_date_decision']);
4068 $valF['archive_date_validite']=$instr->dateDBToForm($valF['archive_date_validite']);
4069 $valF['archive_date_achevement']=$instr->dateDBToForm($valF['archive_date_achevement']);
4070 $valF['archive_date_chantier']=$instr->dateDBToForm($valF['archive_date_chantier']);
4071 $valF['archive_date_conformite']=$instr->dateDBToForm($valF['archive_date_conformite']);
4072 $valF['archive_date_dernier_depot']=$instr->dateDBToForm($valF['archive_date_dernier_depot']);
4073 $valF['archive_date_limite_incompletude']=$instr->dateDBToForm($valF['archive_date_limite_incompletude']);
4074 $valF['date_finalisation_courrier']=$instr->dateDBToForm($valF['date_finalisation_courrier']);
4075 $valF['date_envoi_signature']=$instr->dateDBToForm($valF['date_envoi_signature']);
4076 $valF['date_retour_signature']=$instr->dateDBToForm($valF['date_retour_signature']);
4077 $valF['date_envoi_rar']=$instr->dateDBToForm($valF['date_envoi_rar']);
4078 $valF['date_retour_rar']=$instr->dateDBToForm($valF['date_retour_rar']);
4079 $valF['date_envoi_controle_legalite']=$instr->dateDBToForm($valF['date_envoi_controle_legalite']);
4080 $valF['date_retour_controle_legalite']=$instr->dateDBToForm($valF['date_retour_controle_legalite']);
4081
4082 foreach(explode(";", $type_mise_a_jour) as $maj_date) {
4083 $valF[$maj_date]=$date;
4084 }
4085
4086 // Vérification de la finalisation du document
4087 // correspondant au code barres
4088 if($valF["om_final_instruction"] === 't' or
4089 $valF["lettretype"] == '') {
4090 $code_barres = "";
4091
4092 //Désactivation de l'autocommit
4093 $f->db->autoCommit(false);
4094
4095 //On modifie les valeurs de l'instruction
4096 $instr->setParameter('maj', 170);
4097 $instr->class_actions[170]["identifier"] =
4098 "mise à jour des dates (depuis le menu suivi des pièces)";
4099 $retour = $instr->modifier($valF, $f->db, DEBUG);
4100
4101 //Si une erreur s'est produite, on défait les modifications
4102 //qui ont été faites
4103 if (!$retour){
4104 $instr->undoValidation();
4105 }
4106 //Sinon, on valide en base de données les modifications
4107 else {
4108 $f->db->commit();
4109 }
4110
4111 // Variable correct retourné depuis la classe instruction
4112 $correct = $instr->correct;
4113
4114 // Si la modification sur l'instruction a échoué
4115 if ($correct === false) {
4116
4117 // Message d'erreur de la classe instruction
4118 $error = $instr->msg;
4119 }
4120
4121 } else {
4122 // Indique que le traitement est en erreur
4123 $correct = false;
4124 // Message d'erreur
4125 $error = sprintf(_("Le document n'est pas finalise."),
4126 "<span class='bold'>".$code_barres."</span>");
4127 }
4128 } else {
4129 // Récupération des infos du dossier
4130 $sqlInfo = "SELECT dossier.dossier_libelle,
4131 evenement.libelle as evenement,
4132 autorite_competente.code as autorite_competente_code,
4133 autorite_competente.libelle as autorite_competente,
4134 evenement.type as evenement_type,
4135 to_char(date_envoi_signature,'DD/MM/YYYY') as date_envoi_signature,
4136 to_char(date_retour_signature,'DD/MM/YYYY') as date_retour_signature,
4137 to_char(date_envoi_controle_legalite,'DD/MM/YYYY') as date_envoi_controle_legalite,
4138 to_char(date_retour_controle_legalite,'DD/MM/YYYY') as date_retour_controle_legalite,
4139 to_char(date_envoi_rar,'DD/MM/YYYY') as date_envoi_rar,
4140 to_char(date_retour_rar,'DD/MM/YYYY') as date_retour_rar
4141 FROM ".DB_PREFIXE."instruction
4142 INNER JOIN ".DB_PREFIXE."dossier ON
4143 dossier.dossier=instruction.dossier
4144 LEFT JOIN ".DB_PREFIXE."autorite_competente ON
4145 dossier.autorite_competente=autorite_competente.autorite_competente
4146 INNER JOIN ".DB_PREFIXE."evenement ON
4147 instruction.evenement=evenement.evenement
4148 WHERE code_barres='".$code_barres."'";
4149 $resInfo = $f->db->query($sqlInfo);
4150 $f->isDatabaseError($resInfo);
4151 $infos = $resInfo->fetchRow(DB_FETCHMODE_ASSOC);
4152
4153 // Vérification de la non modification des dates de suivi
4154 foreach(explode(";", $type_mise_a_jour) as $champ) {
4155 if($infos[$champ] != "" AND $infos[$champ] != $date) {
4156 $error = _("Les dates de suivis ne peuvent etre modifiees");
4157 $date_error = true;
4158 }
4159 }
4160 }
4161 } else {
4162 $error = _("Le numero saisi ne correspond a aucun code barres d'instruction.");
4163 }
4164
4165 } else {
4166 $error = _("Tous les champs doivent etre remplis.");
4167 }
4168 }
4169
4170 /**
4171 * Affichage des messages et du formulaire
4172 */
4173 // Affichage du message de validation ou d'erreur
4174 if (isset($message) && isset($message_class) && $message != "") {
4175 $f->displayMessage($message_class, $message);
4176 }
4177 // Affichage du message d'erreur
4178 if(!empty($error)) {
4179 $f->displayMessage("error", $error);
4180 }
4181
4182 // Affichage du message de validation de la saisie
4183 if($correct === true) {
4184 $f->displayMessage("ok", _("Saisie enregistree"));
4185 }
4186 // Inclusion de la classe de gestion des formulaires
4187 require_once "../obj/om_formulaire.class.php";
4188 // Ouverture du formulaire
4189 echo "\t<form";
4190 echo " method=\"post\"";
4191 echo " id=\"suivi_mise_a_jour_des_dates_form\"";
4192 echo " action=\"\"";
4193 echo ">\n";
4194 // Paramétrage des champs du formulaire
4195 if(isset($infos)) {
4196 $champs = array("type_mise_a_jour", "date", "code_barres", "dossier_libelle", "evenement"
4197 , "autorite_competente", "date_envoi_signature",
4198 "date_retour_signature", "date_envoi_controle_legalite",
4199 "date_retour_controle_legalite", "date_envoi_rar",
4200 "date_retour_rar", "is_valid");
4201 } else {
4202 $champs = array("type_mise_a_jour", "date", "code_barres");
4203 }
4204 // Création d'un nouvel objet de type formulaire
4205 $form = new formulaire(NULL, 0, 0, $champs);
4206 // Paramétrage des champs du formulaire
4207 // Parametrage du champ type_mise_a_jour
4208 $form->setLib("type_mise_a_jour", _("Date a mettre a jour")."* :");
4209 if(isset($infos)) {
4210 $form->setType("type_mise_a_jour", "selecthiddenstatic");
4211
4212 } else {
4213 $form->setType("type_mise_a_jour", "select");
4214
4215 }
4216 $form->setVal("type_mise_a_jour", $type_mise_a_jour);
4217 $contenu = array();
4218
4219 $contenu[0][0] = "date_envoi_signature";
4220 $contenu[1][0] = _("date d'envoi pour signature Mairie/Prefet");
4221
4222 $contenu[0][1] = "date_retour_signature";
4223 $contenu[1][1] = _("date de retour de signature Mairie/Prefet");
4224
4225 $contenu[0][2] = "date_retour_signature;date_envoi_controle_legalite";
4226 $contenu[1][2] = _("date de retour de signature + Envoi controle legalite");
4227
4228 $contenu[0][3] = "date_envoi_controle_legalite";
4229 $contenu[1][3] = _("date d'envoi au controle de legalite");
4230
4231 $contenu[0][4] = "date_retour_controle_legalite";
4232 $contenu[1][4] = _("date de retour de controle de legalite");
4233
4234 $contenu[0][5] = "date_retour_rar";
4235 $contenu[1][5] = _("date de retour de l'AR");
4236
4237 $form->setSelect("type_mise_a_jour", $contenu);
4238
4239 // Parametrage du champ date
4240 $form->setLib("date", _("Date")."* :");
4241 if(isset($infos)) {
4242 $form->setType("date", "hiddenstaticdate");
4243
4244 } else {
4245 $form->setType("date", "date");
4246 }
4247 $form->setVal("date", $date);
4248 $form->setTaille("date", 10);
4249 $form->setMax("date", 10);
4250
4251 // Parametrage du champ code_barres
4252 $form->setLib("code_barres", _("Code barres d'instruction")."* :");
4253 if(isset($infos)) {
4254 $form->setType("code_barres", "hiddenstatic");
4255 } else {
4256 $form->setType("code_barres", "text");
4257 }
4258 $form->setVal("code_barres", $code_barres);
4259 $form->setTaille("code_barres", 20);
4260 $form->setMax("code_barres", 20);
4261
4262 // Ajout des infos du dossier correspondantes à l'instruction séléctionnée
4263 if(isset($infos)) {
4264
4265 // Tous les champs sont défini par defaut à static
4266 foreach ($infos as $key => $value) {
4267 $form->setType($key, "static");
4268 if(in_array($key, $liste_champs)) {
4269 $form->setVal($key, $date);
4270 } else {
4271 $form->setVal($key, $value);
4272 }
4273 }
4274
4275 // Les champs dont on viens de définir la valeur sont en gras
4276 foreach ($liste_champs as $value) {
4277 $form->setBloc($value,'DF',"",'bold');
4278 }
4279
4280 // Parametrage du champ dossier
4281 $form->setLib("dossier_libelle", _("dossier_libelle")." :");
4282 $form->setType("dossier_libelle", "static");
4283 $form->setVal("dossier_libelle", $infos['dossier_libelle']);
4284
4285 // Parametrage du champ evenement
4286 $form->setLib("evenement", _("evenement")." :");
4287 $form->setType("evenement", "static");
4288 $form->setVal("evenement", $infos['evenement']);
4289
4290 // Parametrage du champ autorite_competente
4291 $form->setLib("autorite_competente", _("Autorite competente")." :");
4292 $form->setType("autorite_competente", "static");
4293 $form->setVal("autorite_competente", $infos['autorite_competente']);
4294
4295 // Parametrage des libellés d'envoi avec RAR
4296 $form->setLib("date_envoi_rar", _("date_envoi_rar")." :");
4297 $form->setLib("date_retour_rar", _("date_retour_rar")." :");
4298
4299 $form->setLib("date_envoi_signature", _("date_envoi_signature")." :");
4300 $form->setLib("date_retour_signature", _("date_retour_signature")." :");
4301 $form->setLib("date_envoi_controle_legalite", _("date_envoi_controle_legalite")." :");
4302 $form->setLib("date_retour_controle_legalite", _("date_retour_controle_legalite")." :");
4303 // Configuration des libellé en fonction de l'autorité compétente
4304 if($infos['autorite_competente_code'] == 'ETAT') {
4305 $form->setType("date_envoi_controle_legalite", "hiddendate");
4306 $form->setType("date_retour_controle_legalite", "hiddendate");
4307 }
4308
4309 // Ajout d'un champ hidden permettant de savoir que le formulaire précédant est celui de vérification
4310 $form->setLib("is_valid", _("Valide")." :");
4311 $form->setType("is_valid", "hidden");
4312 $form->setVal("is_valid", 'true');
4313
4314 $form->setFieldset('dossier_libelle','D',_('Synthese'));
4315 $form->setFieldset('is_valid','F');
4316
4317 }
4318
4319
4320 // Création du fieldset regroupant les champs permettant la mise à jour des date
4321 $form->setFieldset('type_mise_a_jour','D',_('Mise a jour'));
4322 $form->setFieldset('code_barres','F');
4323 // Affichage du formulaire
4324 $form->entete();
4325 $form->afficher($champs, 0, false, false);
4326 $form->enpied();
4327 // Affichage du bouton
4328 echo "\t<div class=\"formControls\">\n";
4329 //
4330 if(!$date_error) {
4331 $f->layout->display_form_button(array("value" => _("Valider"), "name" => "validation"));
4332 }
4333 // Si pas sur l'écran de validation
4334 if(isset($infos)) {
4335 echo "<a class=\"retour\" href=\"../scr/form.php?obj=instruction_suivi_mise_a_jour_des_dates&action=170&idx=0";
4336 echo "&amp;type_mise_a_jour=".$type_mise_a_jour."&amp;date=".$date."&amp;code_barres=".$code_barres;
4337 echo "\">Retour</a>";
4338 }
4339 echo "\t</div>\n";
4340 // Fermeture du formulaire
4341 echo "\t</form>\n";
4342 }
4343
4344 /**
4345 * [view_pdf_lettre_rar description]
4346 *
4347 * @return [type] [description]
4348 */
4349 function view_pdf_lettre_rar() {
4350 // Vérification de l'accessibilité sur l'élément
4351 $this->checkAccessibility();
4352
4353 // XXX APP
4354
4355 $f = $this->f;
4356
4357 $f->disableLog();
4358
4359 if($f->get_submitted_get_value('liste') != null) {
4360 $listeCodeBarres = explode(',',$f->get_submitted_get_value('liste'));
4361
4362 // Classe permettant la mise en page de l'édition pdf
4363 require_once "../obj/pdf_lettre_rar.class.php";
4364 $pdf_lettre_rar = new pdf_lettre_rar('P', 'mm', 'A4');
4365 // Initialisation de la mise en page
4366 $pdf_lettre_rar->init($f);
4367
4368 foreach ($listeCodeBarres as $code_barres) {
4369
4370 // Test si l'evenement est de type arrete et si un délégataire a été nommé
4371 $sql = "SELECT
4372 dossier.dossier_libelle,
4373 evenement.type,
4374 count(lien_dossier_demandeur) as nbdemandeur,
4375 CASE
4376 WHEN division.libelle IS NOT NULL AND phase.code IS NOT NULL
4377 THEN CONCAT(phase.code, ' - ', division.libelle)
4378 ELSE
4379 phase.code
4380 END AS code_phase
4381 FROM ".DB_PREFIXE."instruction
4382 LEFT JOIN ".DB_PREFIXE."dossier
4383 ON instruction.dossier = dossier.dossier
4384 LEFT JOIN ".DB_PREFIXE."division
4385 ON dossier.division = division.division
4386 INNER JOIN ".DB_PREFIXE."evenement ON
4387 instruction.evenement=evenement.evenement
4388 LEFT JOIN ".DB_PREFIXE."phase
4389 ON evenement.phase = phase.phase
4390 inner JOIN ".DB_PREFIXE."lien_dossier_demandeur ON
4391 instruction.dossier=lien_dossier_demandeur.dossier
4392 inner join ".DB_PREFIXE."demandeur on
4393 demandeur.demandeur=lien_dossier_demandeur.demandeur
4394 WHERE code_barres='".$code_barres."'
4395 AND ((lien_dossier_demandeur.petitionnaire_principal IS TRUE AND demandeur.type_demandeur='petitionnaire')
4396 OR demandeur.type_demandeur='delegataire')
4397 GROUP BY dossier.dossier_libelle, evenement.type, phase.code, division.libelle";
4398
4399 $res = $f->db->query($sql);
4400 $f->addToLog(__METHOD__.": db->query(\"".$sql."\")", VERBOSE_MODE);
4401 $f->isDatabaseError($res);
4402 $testDemandeur = $res->fetchrow(DB_FETCHMODE_ASSOC);
4403
4404
4405 // Recuperation de l'adresse de destination
4406 $sqlAdresse = "SELECT
4407 CASE WHEN demandeur.qualite='particulier'
4408 THEN TRIM(CONCAT_WS(' ', pc.libelle, demandeur.particulier_nom, demandeur.particulier_prenom))
4409 ELSE TRIM(demandeur.personne_morale_denomination)
4410 END as ligne1,
4411 CASE WHEN demandeur.qualite='personne_morale'
4412 THEN TRIM(demandeur.personne_morale_raison_sociale)
4413 ELSE ''
4414 END as ligne1_1,
4415 CASE WHEN demandeur.qualite='personne_morale' AND (demandeur.personne_morale_nom IS NOT NULL OR demandeur.personne_morale_prenom IS NOT NULL)
4416 THEN TRIM(CONCAT_WS(' ', 'rep. par', demandeur.personne_morale_nom, demandeur.personne_morale_prenom))
4417 ELSE ''
4418 END as ligne1_2,
4419 trim(concat(demandeur.numero,' ',demandeur.voie)) as ligne2,
4420 CASE demandeur.complement
4421 WHEN null THEN ''
4422 ELSE trim(demandeur.complement)
4423 END as ligne3,
4424 CASE demandeur.lieu_dit
4425 WHEN null THEN ''
4426 ELSE trim(demandeur.lieu_dit)
4427 END as ligne4,
4428 CONCAT_WS(' ', demandeur.code_postal, demandeur.localite,
4429 (CASE WHEN demandeur.bp IS NOT NULL
4430 THEN CONCAT_WS(' ', 'BP', demandeur.bp)
4431 ELSE ''
4432 END),
4433 (CASE WHEN demandeur.cedex IS NOT NULL
4434 THEN CONCAT_WS(' ', 'CEDEX', demandeur.cedex)
4435 ELSE ''
4436 END))
4437 as ligne5,
4438 code_barres as code_barres
4439 FROM ".DB_PREFIXE."instruction
4440 INNER JOIN ".DB_PREFIXE."dossier ON dossier.dossier = instruction.dossier
4441 INNER JOIN ".DB_PREFIXE."lien_dossier_demandeur ON dossier.dossier = lien_dossier_demandeur.dossier
4442 INNER JOIN ".DB_PREFIXE."demandeur ON lien_dossier_demandeur.demandeur = demandeur.demandeur
4443 LEFT OUTER JOIN ".DB_PREFIXE."civilite as pc ON demandeur.particulier_civilite = pc.civilite OR demandeur.personne_morale_civilite = pc.civilite
4444 WHERE instruction.code_barres ='".$code_barres."'";
4445
4446 // Envoi pour delegataire ou petitionnaire principal selon le type d'evenement
4447 if($testDemandeur['type'] != 'arrete' AND $testDemandeur['nbdemandeur'] > 1) {
4448 $sqlAdresse .= " AND demandeur.type_demandeur='delegataire'";
4449 } else {
4450 $sqlAdresse .= " AND lien_dossier_demandeur.petitionnaire_principal IS TRUE AND demandeur.type_demandeur='petitionnaire'";
4451 }
4452
4453 $resAdresse = $f->db->query($sqlAdresse);
4454 $adresse_dest = $resAdresse->fetchrow(DB_FETCHMODE_ASSOC);
4455 $f->addToLog(__METHOD__.": db->query(\"".$sqlAdresse."\")", VERBOSE_MODE);
4456 $f->isDatabaseError($resAdresse);
4457
4458 // Création adresse destinataire sans ligne vide
4459 $adresse_destinataire = array();
4460 if (!empty($adresse_dest['ligne1'])) {
4461 $adresse_destinataire[] = $adresse_dest['ligne1'];
4462 }
4463 if (!empty($adresse_dest['ligne1_1'])) {
4464 $adresse_destinataire[] = $adresse_dest['ligne1_1'];
4465 }
4466 if (!empty($adresse_dest['ligne1_2'])) {
4467 $adresse_destinataire[] = $adresse_dest['ligne1_2'];
4468 }
4469 $adresse_destinataire[] = $adresse_dest['ligne2'];
4470 if (!empty($adresse_dest['ligne3'])) {
4471 $adresse_destinataire[] = $adresse_dest['ligne3'];
4472 }
4473 if (!empty($adresse_dest['ligne4'])) {
4474 $adresse_destinataire[] = $adresse_dest['ligne4'];
4475 }
4476 $adresse_destinataire[] = $adresse_dest['ligne5'];
4477
4478 // Création du champ specifique
4479 $specifique_content = array();
4480 $specifique_content[] = $adresse_dest['ligne1'];
4481 $specifique_content[] = $adresse_dest['ligne1_1'];
4482 $specifique_content[] = $adresse_dest['ligne1_2'];
4483 $specifique_content[] = $testDemandeur['dossier_libelle'];
4484 $specifique_content[] = "|||||".$adresse_dest['code_barres']."|||||";
4485 unset($adresse_dest['code_barres']);
4486
4487 // Ajout d'une page aux pdf
4488 $pdf_lettre_rar->addLetter($adresse_destinataire, $specifique_content, $testDemandeur['code_phase']);
4489
4490 }
4491 $pdf_output = $pdf_lettre_rar->output("lettre_rar".date("dmYHis").".pdf","S");
4492 require_once PATH_OPENMAIRIE."om_edition.class.php";
4493 $om_edition = new edition();
4494 $om_edition->expose_pdf_output($pdf_output, "lettre_rar".date("dmYHis").".pdf");
4495 }
4496 }
4497
4498 /**
4499 * VIEW - view_bordereau_envoi_maire.
4500 *
4501 * Formulaire demandant :
4502 * - le code-barres de l'événement d'instruction
4503 * - la date d'envoi du courrier pour signature par le maire
4504 *
4505 * Lors de la validation :
4506 * => met à jour cette date dans l'événement d'instruction
4507 * => crée un lien permettant de générer en PDF le bordereau
4508 *
4509 * @return void
4510 */
4511 function view_bordereau_envoi_maire() {
4512 // Vérification de l'accessibilité sur l'élément
4513 $this->checkAccessibility();
4514
4515 // Récupération des valeur passées en POST ou GET
4516 $code_barres = "";
4517 if($this->f->get_submitted_post_value('code_barres') !== null) {
4518 $code_barres = $this->f->get_submitted_post_value('code_barres');
4519 } elseif($this->f->get_submitted_get_value('code_barres')!==null) {
4520 $code_barres = $this->f->get_submitted_get_value('code_barres');
4521 }
4522 $date = "";
4523 if($this->f->get_submitted_post_value('date') !== null) {
4524 $date = $this->f->get_submitted_post_value('date');
4525 } elseif($this->f->get_submitted_get_value('date') !== null) {
4526 $date = $this->f->get_submitted_get_value('date');
4527 }
4528 $validation = 0;
4529 if($this->f->get_submitted_post_value('validation') !== null) {
4530 $validation = $this->f->get_submitted_post_value('validation');
4531 } elseif($this->f->get_submitted_get_value('validation') !== null) {
4532 $validation = $this->f->get_submitted_get_value('validation');
4533 }
4534
4535 // Si le formulaire a été validé
4536 if ($this->f->get_submitted_post_value('validation') !== null) {
4537 // Tous les champs doivent obligatoirement être remplis
4538 if (!empty($date) && !empty($code_barres)) {
4539 $date_en = $this->dateDB($date);
4540 // Si date valide
4541 if ($date_en != "") {
4542 $id_instruction = $this->get_instruction_by_barcode($code_barres);
4543 // Si un événement d'instruction a été trouvé pour ce code-barres
4544 if ($id_instruction !== null) {
4545 $ret = $this->update_date_envoi_signature($id_instruction, $date_en);
4546 // Si mise à jour réussie de la date d'envoi du courrier
4547 // pour signature par l'autorité compétente
4548 if($ret === true) {
4549 // Message de validation avec lien PDF
4550 $message_class = "valid";
4551 $message = '&bullet; '._("Veuillez cliquer sur le lien ci-dessous pour telecharger votre bordereau");
4552 $message .= " : <br/><br/>";
4553 $message .= "<a class='om-prev-icon pdf-16'";
4554 $message .= " id=\"generer_bordereau_envoi_maire\"";
4555 $message .= " title=\""._("Bordereau")."\"";
4556 $message .= " href='../scr/form.php?obj=instruction";
4557 $message .= "&action=200";
4558 $message .= "&idx=".$id_instruction."'";
4559 $message .= " target='_blank'>";
4560 $message .= _("Bordereau d'envoi au maire");
4561 $message .= "</a><br/><br/>";
4562 $message .= '&bullet; '._("Rappel des informations saisies")." :<br/><br/>";
4563 $message .= _("Code du courrier")." : ".$code_barres."<br/>";
4564 $message .= _("Date d'envoi du courrier pour signature par le maire")." : ".$date;
4565
4566 } else {
4567 // Message d'erreur
4568 $message_class = "error";
4569 $message = sprintf(_("Erreur lors de la mise a jour de l'evenement d'instruction correspondant au code barres %s."),
4570 $code_barres);
4571 }
4572 }
4573 else {
4574 $message_class = "error";
4575 $message = _("Le numero saisi ne correspond a aucun code-barres d'evenement d'instruction.");
4576 }
4577 }
4578 else {
4579 $message_class = "error";
4580 $message = _("La date est invalide.");
4581 }
4582 } else {
4583 $message_class = "error";
4584 $message = _("Tous les champs doivent etre remplis.");
4585 }
4586 }
4587
4588 /**
4589 * Affichage des messages et du formulaire
4590 */
4591
4592 // Affichage du message de validation ou d'erreur
4593 if (isset($message) && isset($message_class) && $message != "") {
4594 $this->f->displayMessage($message_class, $message);
4595 }
4596
4597 // Inclusion de la classe de gestion des formulaires
4598 require_once "../obj/om_formulaire.class.php";
4599 // Ouverture du formulaire
4600 $datasubmit = $this->getDataSubmit();
4601 echo "\n<!-- ########## START DBFORM ########## -->\n";
4602 echo "<form";
4603 echo " id=\"bordereau_envoi_maire\"";
4604 echo " method=\"post\"";
4605 echo " name=\"f1\"";
4606 echo " action=\"";
4607 echo $datasubmit;
4608 echo "\"";
4609 echo ">\n";
4610
4611 // Paramétrage des champs du formulaire
4612 $champs = array("code_barres","date");
4613
4614 // Création d'un nouvel objet de type formulaire
4615 $form = new formulaire(NULL, 0, 0, $champs);
4616
4617 $template_required_label = '%s *';
4618 // Parametrage du champ code_barres
4619 $form->setLib("code_barres", sprintf($template_required_label,_("Code du courrier")));
4620 $form->setType("code_barres", "text");
4621 $form->setVal("code_barres", $code_barres);
4622 $form->setTaille("code_barres", 20);
4623 $form->setMax("code_barres", 20);
4624 // Parametrage du champ date
4625 $form->setLib("date", sprintf($template_required_label,_("Date d'envoi du courrier pour signature par le maire")));
4626 $form->setType("date", "date") ;
4627 if (empty($date)) {
4628 $date = date('d/m/Y');
4629 }
4630 $form->setVal("date", $date);
4631 $form->setTaille("date", 10);
4632 $form->setMax("date", 10);
4633
4634 // Création du bloc regroupant les champs
4635 $form->setBloc('code_barres','D');
4636 $form->setBloc('date','F');
4637 // Affichage du formulaire
4638 $form->entete();
4639 $form->afficher($champs, 0, false, false);
4640 $form->enpied();
4641 // Affichage du bouton
4642 printf("\t<div class=\"formControls\">\n");
4643 //
4644 $this->f->layout->display_form_button(array("value" => _("Valider"), "name" => "validation"));
4645 printf("\t</div>\n");
4646 // Fermeture du formulaire
4647 printf("\t</form>\n");
4648 }
4649
4650 /**
4651 * VIEW - view_bordereau_envoi_maire.
4652 *
4653 * PDF de bordereau d'envoi au maire pour l'événement d'instruction instancié
4654 *
4655 * @return [void]
4656 */
4657 function view_generate_bordereau_envoi_maire() {
4658 // Vérification de l'accessibilité sur l'élément
4659 $this->checkAccessibility();
4660 // Récupération de la collectivité du dossier d'instruction
4661 $collectivite_di = $this->get_dossier_instruction_om_collectivite();
4662 // Récupération de ses paramètres
4663 $collectivite = $this->f->getCollectivite($collectivite_di);
4664 // Génération du PDF
4665 $result = $this->compute_pdf_output('etat', 'communaute_bordereau_envoi_maire', $collectivite, $this->getVal(($this->clePrimaire)));
4666 // Affichage du PDF
4667 $this->expose_pdf_output(
4668 $result['pdf_output'],
4669 $result['filename']
4670 );
4671 }
4672
4673 /**
4674 * Retourne l'événement d'instruction dont on donne le code-barres
4675 *
4676 * @param [string] $barcode numéro du code-barres
4677 * @return [mixed] ID de son instruction ou null si aucun code
4678 */
4679 function get_instruction_by_barcode($barcode) {
4680 // Begin
4681 $this->begin_treatment(__METHOD__);
4682 // Vérification de l'existence de l'événement d'instruction
4683 // pour le code-barres donné
4684 $sql = "SELECT instruction
4685 FROM ".DB_PREFIXE."instruction
4686 WHERE code_barres = '".$this->f->db->escapesimple($barcode)."'";
4687 $res = $this->f->db->getOne($sql);
4688 $this->f->addToLog(__METHOD__." : db->getOne(\"".$sql."\")", VERBOSE_MODE);
4689 $this->f->isDatabaseError($res);
4690 // Retourne résultat
4691 return $this->end_treatment(__METHOD__, $res);
4692 }
4693
4694 /**
4695 * Met à jour le champ date d'envoi signature
4696 * avec la date fournie et pour l'instruction donnée
4697 *
4698 * @param [string] $id ID de l'événement d'instruction
4699 * @param [string] $date date au format EN
4700 * @return [boolean] true si mise à jour avec succès
4701 */
4702 function update_date_envoi_signature($id, $date) {
4703 // Préparation du tableau
4704 $valF = array();
4705 $valF['date_envoi_signature'] = $date;
4706 // Begin
4707 $this->begin_treatment(__METHOD__);
4708 // Requête
4709 $res = $this->db->autoExecute(
4710 DB_PREFIXE.$this->table,
4711 $valF,
4712 DB_AUTOQUERY_UPDATE,
4713 $this->getCle($id)
4714 );
4715 // S'il y a eu une erreur
4716 if (database::isError($res, true)) {
4717 $this->end_treatment(__METHOD__, false);
4718 }
4719 //
4720 return $this->end_treatment(__METHOD__, true);
4721 }
4722
4723 /**
4724 * Méthode permettant de définir des valeurs à envoyer en base après
4725 * validation du formulaire d'ajout.
4726 * @param array $val tableau des valeurs retournées par le formulaire
4727 */
4728 function setValFAjout($val) {
4729 // Mise à jour du flag created_by_commune lors d'un changement de décision
4730 // par un utilisateur de commune sur un dossier instruit par la comcom
4731 if($this->f->isInstrCanChangeDecision($this->valF["dossier"])) {
4732 $this->valF['created_by_commune'] = true;
4733 }
4734 }
4735
4736 /**
4737 * Récupère l'instance du dossier d'instruction
4738 *
4739 * @param mixed Identifiant du dossier d'instruction
4740 *
4741 * @return object
4742 */
4743 function get_inst_dossier($dossier = null) {
4744 //
4745 return $this->get_inst_common("dossier", $dossier);
4746 }
4747
4748 /**
4749 * Récupère l'instance d'un événement de workflow.
4750 *
4751 * @param mixed $evenement Identifiant de l'événement.
4752 *
4753 * @return object
4754 */
4755 function get_inst_evenement($evenement = null) {
4756 //
4757 return $this->get_inst_common("evenement", $evenement);
4758 }
4759
4760 /**
4761 * Logue l'action de l'instruction dans son DI.
4762 *
4763 * @param string $id Clé primaire de l'instruction.
4764 * @param array $val Valeurs de l'instruction.
4765 *
4766 * @return bool Vrai si traitement effectué avec succès
4767 */
4768 private function add_log_to_dossier($id, array $val) {
4769 $maj = $this->getParameter("maj");
4770 // Action = Trace par défaut
4771 $action = $this->get_backtrace();
4772 // Action = Identifant de l'action si contexte connu
4773 if (empty($maj) === false
4774 || (empty($maj) === true && $maj === 0)) {
4775 $action = $this->get_action_param($maj, 'identifier');
4776 if ($action === 'modifier_suivi') {
4777 $action = "modifier (via l'action suivi des dates)";
4778 }
4779 if ($action === 'notifier_commune'
4780 && isset($val['mails_destinataires']) === true) {
4781 $action = "notification de la commune (courriels : ";
4782 $action .= $val['mails_destinataires'].")";
4783 }
4784 }
4785 // Création du log
4786 $log = array(
4787 'date' => date('Y-m-d H:i:s'),
4788 'user' => $_SESSION['login'],
4789 'action' => $action,
4790 'values' => array(
4791 'date_evenement' => $this->dateDB($val['date_evenement']),
4792 'date_retour_rar' => $this->dateDB($val['date_retour_rar']),
4793 'date_retour_signature' => $this->dateDB($val['date_retour_signature']),
4794 'evenement' => $val['evenement'],
4795 'action' => $val['action'],
4796 'instruction' => $id,
4797 'etat' => $val['etat'],
4798 ),
4799 );
4800 // Ajout du log
4801 $di = $this->get_inst_dossier($val['dossier']);
4802 $ret = $di->add_log_instructions($log);
4803 if ($ret === false) {
4804 $this->correct = false;
4805 $this->msg = '';
4806 $this->addToMessage($di->msg);
4807 }
4808 return $ret;
4809 }
4810
4811
4812 /**
4813 * Retourne le contexte de déboguage formaté en HTML.
4814 *
4815 * @return string Une ligne par trace
4816 */
4817 private function get_backtrace() {
4818 $trace = debug_backtrace();
4819 $backtrace = '';
4820 $i = 1;
4821 foreach ($trace as $key => $value) {
4822 $func = $trace[$key]['function'];
4823 // On ne s'autolog pas
4824 if ($func === 'get_backtrace'
4825 || $func === 'add_log_to_dossier') {
4826 continue;
4827 }
4828 $backtrace .= $i.') ';
4829 // Si dans une classe
4830 if (isset($trace[$key]['class']) === true
4831 && empty($trace[$key]['class']) === false) {
4832 $backtrace .= $trace[$key]['class'].'->'.$func;
4833 }
4834 // Si procédural
4835 else {
4836 $file = $trace[$key]['file'];
4837 $line = $trace[$key]['line'];
4838 $truncated_file = $this->f->get_relative_path($file);
4839 if ($truncated_file !== false) {
4840 $file = $truncated_file;
4841 }
4842 $backtrace .= $func.' IN<br/>&nbsp;&nbsp;&nbsp;&nbsp; '.$file.':'.$line;
4843 }
4844 $backtrace .= '<br/>';
4845 $i++;
4846 }
4847 return $backtrace;
4848 }
4849
4850 /**
4851 * CONDITION - is_notifiable.
4852 *
4853 * Condition pour afficher l'action notifier_commune.
4854 *
4855 * @return boolean
4856 */
4857 public function is_notifiable() {
4858 // L'instruction doit être finalisée, ce qui revient à dire
4859 // définalisable sans bypass
4860 if ($this->is_unfinalizable_without_bypass() === false) {
4861 return false;
4862 }
4863 // La collectivité de l'utilisateur doit être de niveau multi
4864 if ($this->f->has_collectivite_multi() === false) {
4865 return false;
4866 }
4867 // Le paramètre multi de l'objet du courriel doit exister
4868 if ($this->f->getParameter('param_courriel_de_notification_commune_objet_depuis_instruction') === NULL) {
4869 return false;
4870 }
4871 // Le paramètre multi du modèle du courriel doit exister
4872 if ($this->f->getParameter('param_courriel_de_notification_commune_modele_depuis_instruction') === NULL) {
4873 return false;
4874 }
4875 // A ce stade toutes les conditions sont satisfaites
4876 return true;
4877 }
4878
4879 /**
4880 * TREATMENT - notifier_commune.
4881 *
4882 * Notifie aux communes et par courriel la finalisation d'une instruction.
4883 *
4884 * @return boolean
4885 */
4886 public function notifier_commune() {
4887 // Cette méthode permet d'exécuter une routine en début des méthodes
4888 // dites de TREATMENT.
4889 $this->begin_treatment(__METHOD__);
4890 // Définition des paramètres
4891 $p_objet = 'param_courriel_de_notification_commune_objet_depuis_instruction';
4892 $p_modele = 'param_courriel_de_notification_commune_modele_depuis_instruction';
4893 $p_courriel = 'param_courriel_de_notification_commune';
4894 // Définition des variables de substitution
4895 $id_di = $this->getVal('dossier');
4896 $id_inst = $this->getVal($this->clePrimaire);
4897 // Instanciation du DI
4898 $di = $this->get_inst_dossier($id_di);
4899 // Récupération du paramétrage de la collectivité du dossier
4900 $collectivite_di = $di->getVal('om_collectivite');
4901 $params_mono = $this->f->getCollectivite($collectivite_di);
4902 // Récupération du paramétrage de la collectivité multi
4903 $collectivite_multi = $this->f->get_idx_collectivite_multi();
4904 $params_multi = $this->f->getCollectivite($collectivite_multi);
4905 // Vérification de l'objet (obligatoirement multi)
4906 $objet = null;
4907 if (isset($params_multi[$p_objet]) === true
4908 && $params_multi[$p_objet] !== '') {
4909 $objet = $params_multi[$p_objet];
4910 }
4911 // Vérification du modèle mono en priorité
4912 $modele = null;
4913 if (isset($params_mono[$p_modele]) === true
4914 && $params_mono[$p_modele] !== '') {
4915 $modele = $params_mono[$p_modele];
4916
4917 }
4918 // Sinon vérification du modèle multi
4919 if ($modele === null
4920 && isset($params_multi[$p_modele]) === true
4921 && $params_multi[$p_modele] !== '') {
4922 $modele = $params_multi[$p_modele];
4923 }
4924 // Vérification des adresses de courriel mono
4925 $courriels_valides = array();
4926 $courriels_invalides = array();
4927 if (isset($params_mono[$p_courriel]) === true
4928 && $params_mono[$p_courriel] !== '') {
4929 // Un mail par ligne
4930 $adresses = explode("\n", $params_mono[$p_courriel]);
4931 // Vérification de la validité de chaque mail avec preg_match
4932 foreach ($adresses as $adresse) {
4933 $adresse = trim($adresse);
4934 if ($this->f->checkValidEmailAddress($adresse) === 1) {
4935 $courriels_valides[] = $adresse;
4936 } else {
4937 $courriels_invalides[] = $adresse;
4938 }
4939 }
4940 }
4941 // Vérification du paramétrage global :
4942 // on stoppe le traitement si au moins un paramètre est incorrect
4943 if ($objet === null
4944 || $modele === null
4945 || count($courriels_valides) === 0
4946 || count($courriels_invalides) > 0) {
4947 // On construit le message d'erreur adéquat
4948 $this->addToMessage(_('Erreur de paramétrage :'));
4949 if ($objet === null) {
4950 $this->addToMessage(_("* l'objet du courriel envoyé aux communes est vide"));
4951 }
4952 if ($modele === null) {
4953 $this->addToMessage(_("* le modèle du courriel envoyé aux communes est vide"));
4954 }
4955 if (count($courriels_valides) === 0) {
4956 $this->addToMessage(_("* aucun courriel valide de destinataire de la commune"));
4957 }
4958 if (count($courriels_invalides) > 0) {
4959 $courriels_invalides = implode(', ', $courriels_invalides);
4960 $this->addToMessage(_("* un ou plusieurs courriels des destinataires de la commune sont invalides : ").$courriels_invalides);
4961 }
4962 $this->addToMessage(_("Veuillez contacter votre administrateur."));
4963 return $this->end_treatment(__METHOD__, false);
4964 }
4965 // Remplacement des variables de substitution
4966 $objet = str_replace('<DOSSIER_INSTRUCTION>', $id_di, $objet);
4967 $modele = $this->formater_modele($modele, $id_di, $id_inst);
4968 // Exécution du traitement d'envoi du/des mail(s)
4969 $fails = array();
4970 foreach ($courriels_valides as $email) {
4971 if ($this->f->sendMail(
4972 iconv("UTF-8", "CP1252", $objet),
4973 iconv("UTF-8", "CP1252", $modele),
4974 iconv("UTF-8", "CP1252", $email)) === false) {
4975 $fails[] = $email;
4976 }
4977 }
4978 // Si échec message d'erreur et arrêt du traitement
4979 if (count($fails) > 0) {
4980 $fails = implode(', ', $fails);
4981 $this->addToMessage(_("Erreur lors de l'envoi du courriel aux destinataires : ").$fails);
4982 $this->addToMessage(_("Veuillez contacter votre administrateur."));
4983 return $this->end_treatment(__METHOD__, false);
4984 }
4985 // Ajout du log
4986 $this->setValFFromVal();
4987 $val_inst = $this->valF;
4988 $val_inst['mails_destinataires'] = implode(', ', $courriels_valides);
4989 if ($this->add_log_to_dossier($id_inst, $val_inst) === false) {
4990 $this->addToMessage(_("Erreur lors de la notification."));
4991 $this->addToMessage(_("Veuillez contacter votre administrateur."));
4992 return $this->end_treatment(__METHOD__, false);
4993 }
4994 // Message de validation
4995 $this->addToMessage(_('La commune a été notifiée.'));
4996 return $this->end_treatment(__METHOD__, true);
4997 }
4998
4999 /**
5000 * Formatte le corps du courriel notifié aux communes
5001 *
5002 * @param string $modele template du modèle du courriel
5003 * @param string $id_di clé primaire du DI
5004 * @param string $id_inst clé primaire de l'instruction
5005 * @return string corps du mail au format HTML
5006 */
5007 public function formater_modele($modele, $id_di, $id_inst) {
5008 // Création du lien d'accès direct à l'instruction
5009 $url_inst = PATH_BASE_URL.'spg/direct_link.php?obj=dossier_instruction&action=3'.
5010 '&direct_field=dossier&direct_form=instruction&direct_action=3&direct_idx='.$id_inst;
5011 $url_inst = '<a href="'.$url_inst.'">'.$url_inst.'</a>';
5012 // Remplacement des champs de fusion
5013 $modele = str_replace('<DOSSIER_INSTRUCTION>', $id_di, $modele);
5014 $modele = str_replace('<URL_INSTRUCTION>', $url_inst, $modele);
5015 $modele = str_replace('<ID_INSTRUCTION>', $id_inst, $modele);
5016 // Encodage HTML des sauts de ligne
5017 $modele = preg_replace("/\r\n|\r|\n/",'<br/>',$modele);
5018 //
5019 return $modele;
5020 }
5021
5022
5023 /**
5024 * Récupère l'instance de l'instructeur
5025 *
5026 * @param integer $instructeur Identifiant de l'instructeur.
5027 *
5028 * @return object
5029 */
5030 protected function get_inst_instructeur($instructeur) {
5031 //
5032 return $this->get_inst_common("instructeur", $instructeur);
5033 }
5034
5035
5036 /**
5037 * Récupère l'instance de l'utilisateur
5038 *
5039 * @param integer $om_utilisateur Identifiant de l'utilisateur.
5040 *
5041 * @return object
5042 */
5043 protected function get_inst_om_utilisateur($om_utilisateur) {
5044 //
5045 return $this->get_inst_common("om_utilisateur", $om_utilisateur);
5046 }
5047
5048
5049 /**
5050 * Récupère l'instance de la division.
5051 *
5052 * @param integer $division Identifiant de la division.
5053 *
5054 * @return object
5055 */
5056 protected function get_inst_division($division) {
5057 //
5058 return $this->get_inst_common("division", $division);
5059 }
5060
5061
5062 /**
5063 * Récupère l'instance de la direction.
5064 *
5065 * @param integer $direction Identifiant de la direction.
5066 *
5067 * @return object
5068 */
5069 protected function get_inst_direction($direction) {
5070 //
5071 return $this->get_inst_common("direction", $direction);
5072 }
5073
5074
5075 /**
5076 * Récupère la collectivité d'un instructeur en passant par sa division puis
5077 * par sa direction.
5078 *
5079 * @param integer $instructeur Identifiant de l'instructeur.
5080 *
5081 * @return integer
5082 */
5083 protected function get_instructeur_om_collectivite($instructeur) {
5084 // Chemin vers la collectivité d'un instructeur
5085 $inst_instr = $this->get_inst_instructeur($instructeur);
5086 $inst_division = $this->get_inst_division($inst_instr->getVal('division'));
5087 $inst_direction = $this->get_inst_direction($inst_division->getVal('direction'));
5088
5089 // Collectivité
5090 $om_collectivite = $inst_direction->getVal('om_collectivite');
5091
5092 //
5093 return $om_collectivite;
5094 }
5095
5096
5097 }// fin classe
5098
5099 ?>

[email protected]
ViewVC Help
Powered by ViewVC 1.1.26