trunk/obj/instruction.class.php

<?php
/**
 *
 *
 * specific :
 * - cle secondaire
 *   destruction autorisée que pour le dernier evenement
 *     [delete the last event ]
 * - variable globale [global variables]
 *     var $archive_date_depot;
 *     var $retourformulaire;
 *     var $idxformulaire;
 * - modification des données dans dossier trigger avant
 * [modify dossier data with trigger function]
 * - function mois_date : pour ajouter des mois a une date
 *   [add months (delay) and calculation final date]
 * - voir script_lang.js : bible ...
 * 
 * @package openfoncier
 * @version SVN : $Id$
 */

//
require_once "../gen/obj/instruction.class.php";

//
require_once "../services/outgoing/messageenqueuer.php";

//
class instruction extends instruction_gen {

    var $archive_date_depot; // specific
    var $retourformulaire;   // specific
    var $idxformulaire;      // specific
    var $valEvenement;
    // Tableau contenant une partie des métadonnées arrêtés
    var $metadonneesArrete;

    var $metadata = array(
        "om_fichier_instruction" => array(
            "dossier" => "getDossier",
            "dossier_version" => "getDossierVersion",
            "numDemandeAutor" => "getNumDemandeAutor",
            "anneemoisDemandeAutor" => "getAnneemoisDemandeAutor",
            "typeInstruction" => "getTypeInstruction",
            "statutAutorisation" => "getStatutAutorisation",
            "typeAutorisation" => "getTypeAutorisation",
            "dateEvenementDocument" => "getDateEvenementDocument",
            "groupeInstruction" => 'getGroupeInstruction',
            "title" => 'getTitle',
        ),
    );


    function __construct($id, &$db, $debug) {
        $this->constructeur($id, $db, $debug);
    }

    // {{{ Gestion de la confidentialité des données spécifiques

    /**
     * Surcharge pour gérer les actions disponibles dans le portlet
     */
    function checkAccessibility() {
        //
        parent::checkAccessibility();
        // Si l'utilisateur est un intructeur qui ne correspond pas à la
        // division du dossier
        if ($this->f->isUserInstructeur()
            && isset($this->f->om_utilisateur["division"])
            && $this->f->om_utilisateur["division"] != $this->getDivisionFromDossier()) {
            //
            //On cache les liens d'action
            $this->parameters["actions"]["modifier"] = NULL;
            $this->parameters["actions"]["supprimer"] = NULL;
            $this->actions_sup["finalisation"] = NULL;
        }
        // Si une action 'lu' est présente et que le champ lu est à true
        // on supprime l'action
        if (isset($this->actions_sup["lu"])
            && isset($this->val[array_search("lu", $this->champs)])
            && $this->val[array_search("lu", $this->champs)]== "t") {
            unset($this->actions_sup["lu"]);
        }
            
        //Si le document est déjà finalisé, on affiche uniquement le lien de 
        //dé-finalisation
        $om_final_instruction = $this->getVal("om_final_instruction");
        if ( isset($this->actions_sup["finalisation"]) &&
            $om_final_instruction== "t" ){
                
            //On cache les liens d'action
            $this->parameters["actions"]["modifier"] = NULL;
            $this->parameters["actions"]["supprimer"] = NULL;
            //On cache le lien de finalisation et on affiche le bon lien pour l'édition
            $this->actions_sup["finalisation"] = NULL;
            $this->actions_sup["pdfetat"]["lien"] = "../spg/file.php?id=";
            $this->actions_sup["pdfetat"]["id"] = 
                "&amp;obj=instruction&amp;champ=om_fichier_instruction";
        }
        //Si le document n'est pas finalisé, on affiche uniquement le lien de 
        //finalisation
        if ( isset($this->actions_sup["definalisation"]) &&
            $om_final_instruction!= "t" ){
                
            //On cache le lien de finalisation et on affiche le bon lien pour l'édition
            $this->actions_sup["definalisation"] = NULL;
            $this->actions_sup["pdfetat"]["lien"] = "../app/pdf_instruction.php?idx=";
            $this->actions_sup["pdfetat"]["id"] = "";
        }
        
        $idxformulaire = $this->getParameter("idxformulaire");
        $retourformulaire = $this->getParameter("retourformulaire");
        //Si le dossier d'instruction auquel est rattachée l'instruction est cloturé,
        //on affiche pas les liens du portlet
        if ( $idxformulaire != '' && 
            (
                $retourformulaire == 'dossier' ||
                $retourformulaire == 'dossier_instruction' ||
                $retourformulaire == 'dossier_instruction_mes_encours' ||
                $retourformulaire == 'dossier_instruction_tous_encours' ||
                $retourformulaire == 'dossier_instruction_mes_clotures' ||
                $retourformulaire == 'dossier_instruction_tous_clotures'
            )){

            //On récuppère le statut du dossier d'instruction        
            $statut = $this->getStatutAutorisationDossier($idxformulaire);
            // Si l'utilisateur est un instructeur, que le statut est clôturé
            // et que l'événement n'est pas identifié comme non verrouillable
            if ( $this->f->isUserInstructeur() && $statut == "cloture" 
                && $this->checkEvenementNonVerrouillable($this->getVal("instruction")) === false){
                
                //On cache les liens du portlet
                $this->parameters["actions"]["modifier"] = NULL;
                $this->actions_sup["finalisation"] = NULL;
                $this->actions_sup["definalisation"] = NULL;
            }
        }
    }

    /**
     * Cette methode est à surcharger elle permet de tester dans chaque classe
     * des droits des droits spécifiques en fonction des données
     */
    function canAccess() {
        // Si l'utilisateur est un intructeur qui ne correspond pas à la
        // division du dossier
        if ($this->f->isUserInstructeur()
            && $this->f->om_utilisateur["division"] != $this->getDivisionFromDossier()
            && $this->getParameter("maj") != 3) {
            //
            $this->addToLog("canAccess(): utilisateur instructeur sur un dossier d'une autre division", EXTRA_VERBOSE_MODE);
            return false;
        }

        $retourformulaire = $this->getParameter("retourformulaire");
        // Si l'utilisateur est un instructeur, que le dossier est cloturé,
        // que l'utilisateur est dans un sous formulaire précis, que le 
        // formulaire n'est pas en mode consulter ou ajouter et que l'événement 
        // n'est pas identifié comme non verrouillable
        if ( $this->f->isUserInstructeur() && 
            $this->getStatutAutorisationDossier($this->getParameter("idxformulaire")) == "cloture" 
            && (
                $retourformulaire == 'dossier' ||
                $retourformulaire == 'dossier_instruction' ||
                $retourformulaire == 'dossier_instruction_mes_encours' ||
                $retourformulaire == 'dossier_instruction_tous_encours' ||
                $retourformulaire == 'dossier_instruction_mes_clotures' ||
                $retourformulaire == 'dossier_instruction_tous_clotures'
            ) 
            && $this->getParameter("maj") != 3 
            && $this->getParameter("maj") != 0
            && $this->checkEvenementNonVerrouillable($this->getVal("instruction")) === false) {

            return false;
        }
        //
        return true;
    }

    /**
     * Cette variable permet de stocker le résultat de la méthode
     * getDivisionFromDossier() afin de ne pas effectuer le recalcul à chacun de
     * ces appels.
     * @var string Code de la division du dossier en cours
     */
    var $_division_from_dossier = NULL;

    /**
     * Cette méthode permet de récupérer le code de division correspondant
     * au dossier sur lequel on se trouve.
     *
     * @return string Code de la division du dossier en cours
     */
    function getDivisionFromDossier() {

        // Cette méthode peut être appelée plusieurs fois lors d'une requête.
        // Pour éviter de refaire le traitement de recherche de la division
        // alors on vérifie si nous ne l'avons pas déjà calculé.
        if ($this->_division_from_dossier != NULL) {
            // Logger
            $this->addToLog("getDivisionFromDossier(): retour de la valeur déjà calculée - '".$this->_division_from_dossier."'", EXTRA_VERBOSE_MODE);
            // On retourne la valeur déjà calculée
            return $this->_division_from_dossier;
        }

        // Par défaut, on définit la valeur du dossier à NULL
        $dossier = NULL;
        // Test sur le mode et le contexte du formulaire
        if ($this->getParameter("maj") == 0
            && ($this->getParameter("retourformulaire") == "dossier"
                || $this->getParameter("retourformulaire") == "dossier_instruction"
                || $this->getParameter("retourformulaire") == "dossier_instruction_mes_encours"
                || $this->getParameter("retourformulaire") == "dossier_instruction_tous_encours"
                || $this->getParameter("retourformulaire") == "dossier_instruction_mes_clotures"
                || $this->getParameter("retourformulaire") == "dossier_instruction_tous_clotures")) {
            // Si on se trouve en mode AJOUT (seul mode où l'enregistrement
            // n'existe pas en base de données) ET que nous nous trouvons
            // dans le contexte d'un dossier d'instruction alors on récupère
            // le numéro de dossier depuis le paramètre 'idxformulaire'
            $dossier = $this->getParameter("idxformulaire");
        } else {
            // Sinon on récupère le numéro de dossier dans le champs dossier de
            // l'enregistrement (en base de données)
            $dossier = $this->getVal("dossier");
        }

        // On appelle la méthode de la classe utils qui renvoi le code de la
        // division d'un dossier, on la stocke pour ne pas refaire le calcul au
        // prochain appel de cette méthode
        $this->_division_from_dossier = $this->f->getDivisionFromDossier($dossier);
        // Logger
        $this->addToLog("getDivisionFromDossier(): retour de la valeur nouvellement calculée - '".$this->_division_from_dossier."'", EXTRA_VERBOSE_MODE);
        // On retourne la valeur retournée
        return $this->_division_from_dossier;

    }

    /**
     * Cette méthode permet de récupérer le dossier d'autorisation d'un dossier
     */
    function getNumDemandeAutorFromDossier($id) {
        //
        if (!isset($id)) {
            return NULL;
        }
        //
        $sql = "select dossier_autorisation from ".DB_PREFIXE."dossier ";
        $sql .= " where dossier='".$id."'";
        //
        $dossier_autorisation = $this->db->getOne($sql);
        $this->addToLog("getNumDemandeAutorFromDossier(): db->getone(\"".$sql."\")", VERBOSE_MODE);
        database::isError($dossier_autorisation);
        //
        return $dossier_autorisation;
    }

    // }}}

    function setType(&$form, $maj) {
        //
        parent::setType($form, $maj);
        // On cache tous les champs
        // XXX
        $form->setType('complement3_om_html', 'hidden');
        $form->setType('bible3', 'hidden');
        $form->setType('complement4_om_html', 'hidden');
        $form->setType('bible4', 'hidden');
        $form->setType('complement5_om_html', 'hidden');
        $form->setType('bible5', 'hidden');
        $form->setType('complement6_om_html', 'hidden');
        $form->setType('bible6', 'hidden');
        $form->setType('complement7_om_html', 'hidden');
        $form->setType('bible7', 'hidden');
        $form->setType('complement8_om_html', 'hidden');
        $form->setType('bible8', 'hidden');
        $form->setType('complement9_om_html', 'hidden');
        $form->setType('bible9', 'hidden');
        $form->setType('complement10_om_html', 'hidden');
        $form->setType('bible10', 'hidden');
        $form->setType('complement11_om_html', 'hidden');
        $form->setType('bible11', 'hidden');
        $form->setType('complement12_om_html', 'hidden');
        $form->setType('bible12', 'hidden');
        $form->setType('complement13_om_html', 'hidden');
        $form->setType('bible13', 'hidden');
        $form->setType('complement14_om_html', 'hidden');
        $form->setType('bible14', 'hidden');
        $form->setType('complement15_om_html', 'hidden');
        $form->setType('bible15', 'hidden');
        //
        $form->setType('delai', 'hidden');
        $form->setType('etat', 'hidden');
        $form->setType('accord_tacite', 'hidden');
        $form->setType('action', 'hidden');
        $form->setType('delai_notification', 'hidden');
        $form->setType('avis_decision', 'hidden');
        $form->setType('autorite_competente', 'hidden');
        //
        $form->setType('archive_delai', 'hidden');
        $form->setType('archive_etat', 'hidden');
        $form->setType('archive_accord_tacite', 'hidden');
        $form->setType('archive_avis', 'hidden');
        $form->setType('archive_date_complet', 'hidden');
        $form->setType('archive_date_dernier_depot', 'hidden');
        $form->setType('archive_date_rejet', 'hidden');
        $form->setType('archive_date_limite', 'hidden');
        $form->setType('archive_date_notification_delai', 'hidden');
        $form->setType('archive_date_decision', 'hidden');
        $form->setType('archive_date_validite', 'hidden');
        $form->setType('archive_date_achevement', 'hidden');
        $form->setType('archive_date_conformite', 'hidden');
        $form->setType('archive_date_chantier', 'hidden');
        $form->setType('archive_autorite_competente','hidden');
        //
        $form->setType('numero_arrete', 'hidden');
        //
        $form->setType('code_barres', 'hidden');
        
        //
        $form->setType('archive_incompletude','hidden');
        $form->setType('archive_evenement_suivant_tacite','hidden');
        $form->setType('archive_evenement_suivant_tacite_incompletude','hidden');
        $form->setType('archive_etat_pendant_incompletude','hidden');
        $form->setType('archive_date_limite_incompletude','hidden');
        $form->setType('archive_delai_incompletude','hidden');

        //
        $form->setType('duree_validite','hidden');
        $form->setType('duree_validite_parametrage','hidden');
        if ($maj < 2) { //ajouter et modifier
            $form->setType('destinataire', 'hidden');
            $form->setType('lettretype', 'hiddenstatic');
            $form->setType('complement_om_html', 'html');
            $form->setType('complement2_om_html', 'html');
            $form->setType('bible_auto', 'httpclick');
            $form->setType('bible', 'httpclick');
            $form->setType('bible2', 'httpclick');
            $form->setType('dossier', 'hidden');   
            $form->setType('libelle', 'hiddenstatic');
            $form->setType('signataire_arrete','select');
            $form->setType('date_envoi_signature','datedisabled');
            $form->setType('date_retour_signature','datedisabled');
            $form->setType('date_envoi_rar','datedisabled');
            $form->setType('date_retour_rar','datedisabled');
            $form->setType('date_envoi_controle_legalite','datedisabled');
            $form->setType('date_retour_controle_legalite','datedisabled');
            $form->setType('date_finalisation_courrier','datedisabled');

            
            if($maj==0){ // add
                $form->setType('instruction', 'hidden');
                $form->setType('lettretype', 'hidden');
                $form->setType('evenement', 'select');
                $form->setType('date_evenement', 'date2');
            }else{ // modify
                $form->setType('instruction', 'hiddenstatic');
                $form->setType('evenement', 'selecthiddenstatic');
                //$form->setType('date_evenement', 'hiddenstaticdate');
                $form->setType('date_evenement', 'date2');
                // necessaire pour calcul de date en modification
                //$form->setType('delai', 'hiddenstatic');
                // l'administrateur peut modifier les champs de retour de date
                if ($this->f->user_is_admin == true) {
                    $form->setType('date_retour_signature','date');
                    $form->setType('date_retour_rar','date');
                    $form->setType('date_retour_controle_legalite','date');
                }
            }
        } elseif($maj==2){
            $form->setType('dossier', 'hidden');
            $form->setType('bible_auto', 'hidden');
            $form->setType('bible', 'hidden');
            $form->setType('bible2', 'hidden');
        }else {
            $form->setType('destinataire', 'hidden');
            $form->setType('dossier', 'hidden');
            $form->setType('bible_auto', 'hidden');
            $form->setType('bible', 'hidden');
            $form->setType('bible2', 'hidden');
        }

        //Cache les champs pour la finalisation
        $form->setType('om_fichier_instruction', 'hidden');
        $form->setType('om_final_instruction', 'hidden');
        // Cache le document arrêté
        $form->setType('document_numerise', 'hidden');
        
        //Masquer les champs date_envoi_controle_legalite et 
        //date_retour_controle_legalite si ce n'est pas un arrêté
        if ( !is_numeric($this->getVal("avis_decision"))){
            
            $form->setType("date_envoi_controle_legalite", "hidden");
            $form->setType("date_retour_controle_legalite", "hidden");
        }
    }

    function setSelect(&$form, $maj,&$db,$debug) {
        /**
         * On ne surcharge pas la méthode parent car une requête sur la table
         * dossier est mauvaise pour les performances, car la requête qui
         * concerne evenement est plus complexe que celle générée et car les
         * champs action, avis_decision et etat ne sont pas utilisés comme des
         * select
         */
        if(file_exists ("../sql/".$db->phptype."/".$this->table.".form.inc.php"))
            include ("../sql/".$db->phptype."/".$this->table.".form.inc.php");
        elseif(file_exists ("../sql/".$db->phptype."/".$this->table.".form.inc"))
            include ("../sql/".$db->phptype."/".$this->table.".form.inc");

        //// action
        //$this->init_select($form, $db, $maj, $debug, "action",
        //                   $sql_action, $sql_action_by_id, false);

        //// avis_decision
        //$this->init_select($form, $db, $maj, $debug, "avis_decision",
        //                   $sql_avis_decision, $sql_avis_decision_by_id, false);

        //// dossier
        //$this->init_select($form, $db, $maj, $debug, "dossier",
        //                   $sql_dossier, $sql_dossier_by_id, false);

        //// etat
        //$this->init_select($form, $db, $maj, $debug, "etat",
        //                   $sql_etat, $sql_etat_by_id, false);

        //// evenement
        //$this->init_select($form, $db, $maj, $debug, "evenement",
        //                   $sql_evenement, $sql_evenement_by_id, false);

        // signataire_arrete
        $this->init_select($form, $db, $maj, $debug, "signataire_arrete",
                           $sql_signataire_arrete, $sql_signataire_arrete_by_id, true);

        /**
         * Gestion du filtre sur les événements de workflow disponibles
         * On récupère ici en fonction de l'état du dossier d'instruction en
         * cours et du type du dossier d'instruction en cours la liste
         * événements disponibles.
         */
        if ($maj == 0) {
            // Récupération des événements par une jointure entre la table dossier
            // et la table transition et la table evenement et la table
            // lien_dossier_instruction_type_evenement en fonction de l'identifiant
            // du dossier d'instruction en cours
            $sql = "SELECT
            evenement.evenement,
            CONCAT(evenement.libelle, ' ['||evenement.action||']') as lib
            FROM ".DB_PREFIXE."dossier
            INNER JOIN ".DB_PREFIXE."lien_dossier_instruction_type_evenement
                ON dossier.dossier_instruction_type=lien_dossier_instruction_type_evenement.dossier_instruction_type
            INNER JOIN ".DB_PREFIXE."evenement
                ON evenement.evenement=lien_dossier_instruction_type_evenement.evenement
            INNER JOIN ".DB_PREFIXE."transition
                ON evenement.evenement = transition.evenement
                AND dossier.etat=transition.etat
            WHERE dossier.dossier='".$this->idxformulaire."'
            ORDER BY evenement.libelle, evenement.action";
            $res = $db->query($sql);
            $this->addToLog("setSelect(): db->query(\"".$sql."\");", VERBOSE_MODE);
            if (database::isError($res)) {
                die($res->getMessage());
            }
            // Remplissage du tableau du select 
            $contenu = array(
                0 => array("",),
                1 => array(_('choisir')." "._('evenement'),)
            );
            while ($row=& $res->fetchRow()) {
                $contenu[0][] = $row[0];
                $contenu[1][] = $row[1];
            }
            $form->setSelect("evenement", $contenu);
        } else {
            $sql = "SELECT
            CONCAT(evenement.libelle, ' ['||evenement.action||']') as lib
            FROM ".DB_PREFIXE."evenement
            WHERE evenement.evenement=".$this->getVal("evenement")."";
            $res = $db->getone($sql);
            $this->addToLog("setSelect(): db->getone(\"".$sql."\");", VERBOSE_MODE);
            if (database::isError($res)) {
                die($res->getMessage());
            }
            //
            $contenu = array(
                0 => array($this->getVal("evenement"),),
                1 => array($res,)
            );
            $form->setSelect("evenement", $contenu);
        }

        /**
         * Gesion des liens vers la bible
         */
        // lien bible_auto
        $contenu = array(_("automatique"));
        $form->setSelect("bible_auto",$contenu);
        // lien bible1
        $contenu = array(_("bible"));
        $form->setSelect("bible",$contenu);
        // lien bible2
        $contenu = array(_("bible"));
        $form->setSelect("bible2",$contenu);
    }

    function cleSecondaire($id, &$db, $val, $DEBUG) {
        //
        parent::cleSecondaire($id, $db, $val, $DEBUG);
        
        $id = $this->getVal($this->clePrimaire);

        
        //Requête de vérification que cet événement d'instruction n'est pas lié 
        //à la création d'un dossier d'instruction
        $sql = "SELECT demande_type.dossier_instruction_type 
            FROM ".DB_PREFIXE."demande_type
            LEFT JOIN ".DB_PREFIXE."demande
            ON demande.demande_type = demande_type.demande_type
            WHERE demande.instruction_recepisse = ".$id;
        $res = $this->db->getOne($sql);
        $this->addToLog("cleSecondaire(): db->getone(\"".$sql."\");", VERBOSE_MODE);
        if (database::isError($res)) {
            die($res->getMessage());
        }

        // Aucune clé secondaire n'a été trouvée ou c'est un événement sans 
        //création de dossier d'instruction, l'événement d'instruction peut être 
        //supprimé
        if ( $this->correct !== false || $res == null || $res == ""){

            // Requête de vérification que cet événement d'instruction est lié
            // à une demande
            $sql = "SELECT demande
                FROM ".DB_PREFIXE."demande
                WHERE instruction_recepisse = ".$id;
            $res = $this->db->getOne($sql);
            $this->addToLog("cleSecondaire(): db->getone(\"".$sql."\");", VERBOSE_MODE);
            if (database::isError($res)) {
                die($res->getMessage());
            }

            //Si c'est un événement d'instruction lié à une demande
            if ($res != null || $res != ""){
                
                require_once "../obj/demande.class.php";
                $demande = new demande($res, $this->db, DEBUG);

                //On met à jour la demande en supprimant la liaison vers 
                //l'événement d'instruction
                $demande->setParameter("maj", 1);
                $valF = array();
                foreach($demande->champs as $identifiant => $champ) {
                    $valF[$champ] = $demande->val[$identifiant];
                }
                $valF['date_demande']=$demande->dateDBToForm($valF['date_demande']);
                $valF['instruction_recepisse']=NULL;
                $ret = $demande->modifier($valF, $this->db, DEBUG);
            }
                 
            /**
             * Vérification que l'élément supprimé est le dernier pour pouvoir
             * remodifier les données de manière itérative.
             */
            // Initialisation
            $dernierevenement = "";
            // Récupération du dernier élément de la table d'instruction qui
            // concerne le dossier en cours
            $sql = "SELECT max(instruction)
            FROM ".DB_PREFIXE."instruction
            WHERE dossier ='".$this->idxformulaire."'";
            $dernierevenement = $db->getOne($sql);
            $this->addToLog("setSelect(): db->getone(\"".$sql."\");", VERBOSE_MODE);
            if (database::isError($dernierevenement)) {
                die($dernierevenement->getMessage());
            }
            // Si on se trouve effectivement sur le dernier evenement d'instruction
            if ($dernierevenement == $id) {
                // Alors on valide la suppression
                $this->correct = true;
                $this->addToMessage(_('Destruction_chronologique'));
            } else {
                // Alors on annule la suppression
                $this->correct = false;
                $this->addToMessage(_("Seul le dernier evenement d'instruction peut etre supprime."));
            }
        }
    }

    /**
     * Vérification de la possibilité ou non de modifier des dates de suivi
     * @param  string $champ champ date à vérifier
     */
    function updateDate($champ) {
        
        //Si le retourformulaire est "dossier_instruction"
        if ($this->retourformulaire == "dossier_instruction") {

            // Vérification de la possibilité de modifier les dates si déjà éditées
            if($this->valF[$champ] != "" AND !$this->f->user_is_admin) {
                // si l'utilisateur n'est pas un admin
                if($this->getVal($champ) != "" AND $this->getVal($champ) != $this->valF[$champ]) {
                    $this->correct = false;
                    $this->addToMessage(_("Les dates de suivis ne peuvent etre modifiees"));
                }
            }
        }
        
        //
        return true;
    }

    // Sélectionne le signataire_arrete par défaut
    function setVal(&$form,$maj,$validation){
        
        // Ajout
        if($maj == 0) {
            
            // Création de la requête
            $sql = "SELECT signataire_arrete
                    FROM ".DB_PREFIXE."signataire_arrete
                    WHERE defaut IS TRUE";
            
            // Exécution de la requête 
            $res = $this->f->db->query($sql);
            $this->f->addToLog("setVal(): db->query(\"".$sql."\");", VERBOSE_MODE);
            if ( database::isError($res)){
                die();
            }
        
            $row = $res->fetchrow(DB_FETCHMODE_ASSOC);
            
            if ( isset($row['signataire_arrete']) && is_numeric($row['signataire_arrete'])){
                
                $form->setVal("signataire_arrete",$row['signataire_arrete']);
            }
        }
    }

    /*Met des valeurs par défaut dans certains des sous-formulaire*/
    function setValsousformulaire(&$form,$maj,$validation,$idxformulaire,$retourformulaire,$typeformulaire){
        if ($validation==0 and $maj<2) {
            if ($maj == 0){
                $form->setVal("destinataire", $idxformulaire);
                $form->setVal("dossier", $idxformulaire);
                $form->setVal("date_evenement", date('Y-m-d'));
            }
            $form->setVal("bible_auto","bible_auto()");
            $form->setVal("bible","bible()");
            $form->setVal("bible2","bible2()");
        }
        $this->retourformulaire=$retourformulaire;
        $this->idxformulaire=$idxformulaire;
    }


    function setLayout(&$form, $maj){
        if ( $maj < 2 OR $maj == 3 ) {
                        /*Champ sur lequel s'ouvre le bloc 1 */
            $form->setBloc('evenement','D',"","col_12");

                $form->setFieldset('evenement','D',_('Evenement'));
                $form->setFieldset('lettretype','F','');
            
            $form->setBloc('lettretype','F');

            $form->setBloc('date_finalisation_courrier','D',"","col_12");

                $form->setFieldset('date_finalisation_courrier','D',_('Dates'));
                    $form->setBloc('date_finalisation_courrier','D',"","col_6");
                    $form->setBloc('date_envoi_controle_legalite','F');

                    $form->setBloc('signataire_arrete','D',"","col_6");
                    $form->setBloc('date_retour_controle_legalite','F');
                $form->setFieldset('date_retour_controle_legalite','F','');
            
            $form->setBloc('date_retour_controle_legalite','F');

            $form->setBloc('complement_om_html','D',"","col_12");
                $form->setFieldset('complement_om_html','D',_('Complement'));
                $form->setFieldset('bible','F','');
            $form->setBloc('bible','F');

            $form->setBloc('complement2_om_html','D',"","col_12");
                $form->setFieldset('complement2_om_html','D',_('Complement 2'));
                $form->setFieldset('bible2','F','');
            $form->setBloc('bible2','F');
        }
    }
    
    function setLib(&$form, $maj) {
        //
        parent::setLib($form, $maj);
        //
        $form->setLib('bible_auto', "");
        $form->setLib('bible', "");
        $form->setLib('bible2', "");
    }

    function triggerajouter($id, &$db, $val, $DEBUG) {
        /**
         * Le code suivant permet de récupérer des valeurs des tables evenement
         * et dossier pour les stocker dans l'instruction :
         * DEPUIS L'EVENEMENT
         * - action
         * - delai
         * - accord_tacite
         * - etat
         * - avis_decision
         * - delai_notification
         * - lettretype
         * - autorite_competente
         * DEPUIS LE DOSSIER D'INSTRUCTION
         * - archive_delai
         * - archive_accord_tacite
         * - archive_etat
         * - archive_avis
         * - date_complet
         * - date_rejet
         * - date_limite
         * - date_notification_delai
         * - date_decision
         * - date_validite
         * - date_achevement
         * - date_chantier
         * - date_conformite
         * - avis_decision
         * Il permet également de stocker la date_depot du dossier d'instruction
         * dans l'attribut $this->archive_date_depot de la classe.
         */
        // Récupération de tous les paramètres de l'événement sélectionné
        $sql = "SELECT * FROM ".DB_PREFIXE."evenement
        WHERE evenement=".$this->valF['evenement'];
        $res = $db->query($sql);
        $this->addToLog("triggerajouter(): db->query(\"".$sql."\");", VERBOSE_MODE);
        if (database::isError($res)) {
            die($res->getMessage());
        }
        while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
            // Récupération de l'identifiant de l'action
            // si une action est paramétrée dans l'événement
            $this->valF['action'] = NULL;
            if (isset($row['action']) and !empty($row['action'])) {
                $this->valF['action']=$row['action'];
            }
            // Récupération de la valeur du délai
            $this->valF['delai'] = $row['delai'];
            // Récupération de l'identifiant de l'état
            // si un état est paramétré dans l'événement 
            $this->valF['etat']=NULL;
            if (isset($row['etat']) and !empty($row['etat'])) {
                $this->valF['etat']=$row['etat'];
            }
            // Récupération de la valeur d'accord tacite
            $this->valF['accord_tacite']=$row['accord_tacite'];
            // Récupération de la valeur du délai de notification
            $this->valF['delai_notification']=$row['delai_notification'];
            // Récupération de l'identifiant de l'avis
            // si un avis est paramétré dans l'événement 
            $this->valF['avis_decision'] = NULL;
            if(isset($row['avis_decision']) and !empty($row['avis_decision'])) {
                $this->valF['avis_decision']=$row['avis_decision'];
            }
            // Récupération de la valeur de l'autorité compétente
            // si l'autorité compétente est paramétré dans l'événement 
            $this->valF['autorite_competente'] = NULL;
            if(isset($row['autorite_competente']) and !empty($row['autorite_competente'])) {
                $this->valF['autorite_competente']=$row['autorite_competente'];
            }
            // Récupération de la valeur de la lettre type
            // Sinon on lui affecte lavaleur par défaut standard
            if ($row['lettretype'] != "") {
                $this->valF['lettretype']=$row['lettretype'];
            } else {
                $this->valF['lettretype'] = "standard"; // XXX 
            }
        }
        // Récupération de toutes les valeurs du dossier d'instruction en cours
        $sql = "SELECT * FROM ".DB_PREFIXE."dossier
        WHERE dossier='".$this->valF['dossier']."'";
        $res = $db->query($sql);
        $this->addToLog("triggerajouter(): db->query(\"".$sql."\");", VERBOSE_MODE);
        if (database::isError($res)) {
            die($res->getMessage());
        }
        $row=& $res->fetchRow(DB_FETCHMODE_ASSOC);
        $this->updateArchiveData($row);
        $this->archive_date_depot = $row['date_depot']; 
                
        // Récupération de la duree de validite du dossier d'autorisation
        $sql = "SELECT duree_validite_parametrage
                FROM ".DB_PREFIXE."dossier_autorisation_type_detaille
                LEFT JOIN ".DB_PREFIXE."dossier_autorisation
                    ON dossier_autorisation.dossier_autorisation_type_detaille = dossier_autorisation_type_detaille.dossier_autorisation_type_detaille
                LEFT JOIN ".DB_PREFIXE."dossier
                    ON dossier.dossier_autorisation = dossier_autorisation.dossier_autorisation
        WHERE dossier.dossier='".$this->valF['dossier']."'";
        $duree_validite_parametrage = $db->getOne($sql);
        $this->addToLog("triggerajouter(): db->getOne(\"".$sql."\");", VERBOSE_MODE);
        database::isError($duree_validite_parametrage);
        if ($duree_validite_parametrage != '') {
            $this->valF['duree_validite_parametrage']= $duree_validite_parametrage;
        }

        // Identifiant du type de courrier
        $idTypeCourrier = '11';
        $idCourrier = str_pad($this->valF["instruction"], 10, "0", STR_PAD_LEFT);
        // Code barres
        $this->valF["code_barres"] = $idTypeCourrier . $idCourrier;
    }
    
    // Test si une restriction est valide
    // return boolean 
    function restrictionIsValid($restriction){

        // Liste des opérateurs possible
        $operateurs = array(">=", "<=", "+", "-");
        // Liste des opérateurs avec espace
        $operateurs_blank = array(" >= ", " <= ", " + ", " - ");

        // Supprime tous les espaces de la chaîne de caractère
        $restriction = str_replace(' ', '', $restriction);
        
        // Met des espace avant et après les opérateurs puis transforme la 
        // chaine en un tableau 
        $tabRestriction = str_replace($operateurs, $operateurs_blank, 
            $restriction);
        $tabRestriction = explode(" ", $tabRestriction);

        // Tableau comprenant les résultat
        $res = array();
        // Compteur pour les résultat
        // commence à 1 car le 0 doit rester inchangé tout au long du traitement
        $j = 1;
        // Comparateur du calcul
        $comparateur = '';
        // Booléen retourné
        $res_bool = true;

        // S'il y a un comparateur
        if (in_array(">=", $tabRestriction)
            || in_array("<=", $tabRestriction)) {

            // Si le tableau n'est pas vide
            if (count($tabRestriction) > 0) {

                // Boucle dans le tableau pour récupérer seulement les valeurs
                foreach ($tabRestriction as $key => $value) {
                    
                    //
                    if (!in_array($value, $operateurs)) {
                        if ($this->getRestrictionValue($value) != false) {
                            $res[] = $this->getRestrictionValue($value);
                        } else {
                            // Message d'erreur
                            $error_message = sprintf(_("Le champ %s de l'instruction %s est vide"), "<span class='bold'>".$value."</span>", "<span class='bold'>".$this->valF["instruction"]."</span>");
                            $this->addToMessage($error_message);
                            // Arrête le traitement
                            return false;
                        }
                    }
                }

                // Boucle dans le tableau
                // commence à 1 car le 0 doit rester inchangé tout au long du 
                // traitement
                for ($i = 1; $i<count($tabRestriction); $i++) {
                    
                    // Récupère le comparateur
                    if ($tabRestriction[$i] === ">=" 
                        || $tabRestriction[$i] === "<=") {
                        $comparateur = $tabRestriction[$i];
                    }

                    // Si l'opérateur qui suit est un "+"
                    if ($tabRestriction[$i] === "+") {
                        $dateDep = $res[$j];
                        unset($res[$j]);$j++;
                        $duree = $res[$j];
                        unset($res[$j]);
                        $res[$j] = $this->f->mois_date($dateDep, $duree, "+");
                    }

                    // Si l'opérateur qui suit est un "-"
                    if ($tabRestriction[$i] === "-") {
                        $dateDep = $res[$j];
                        unset($res[$j]);$j++;
                        $duree = $res[$j];
                        unset($res[$j]);
                        $res[$j] = $this->f->mois_date($dateDep, $duree, "-");
                    }
                }
                
            }

            // Si les tableau des résultats n'est pas vide
            if (count($res) > 0) {
                //
                $res_bool = false;
                // Effectue le test
                if ($comparateur === ">=") {
                    //
                    if (strtotime($res[0]) >= strtotime($res[$j])) {
                        $res_bool = true;
                    }
                }
                if ($comparateur === "<=") {

                    if (strtotime($res[0]) <= strtotime($res[$j])) {
                        $res_bool = true;
                    }
                }
            }
        // Sinon une erreur s'affiche
        } else {

            // Message d'erreur
            $error_message = _("La restriction est sans comparateur");
            $this->addToMessage($error_message);
            // Arrête le traitement
            return false;
        }
        
        return $res_bool;

    }

    /**
     * Récupère la valeur du champ dans la restriction
     * @param  string   $restrictionValue   Nom du champ
     * @return mixed                        Valeur du champ
     */
    function getRestrictionValue($restrictionValue){

        // Initialisation de la valeur de retour
        $return = false;

        // Récupére les valeurs du dossier
        $value_dossier = $this->get_dossier_actual();

        // 
        if (is_numeric($restrictionValue)) {
            $return = $restrictionValue;
        }elseif (isset($value_dossier[$restrictionValue])) {
            $return = $value_dossier[$restrictionValue];
        }elseif (isset($this->valF[$restrictionValue])) {
            $return = $this->valF[$restrictionValue];
        }

        // Retourne la valeur du champ
        return $return;
    }

    /**
     * Calcul des règle d'action.
     * @param string $rule      Règle d'action
     * @param string $rule_name Nom de la règle
     * @param string $type      Type de la règle
     * 
     * @return mixed            Résultat de la règle
     */
    function regle($rule, $rule_name, $type = null) {

        // Supprime tous les espaces de la chaîne de caractère
        $rule = str_replace(' ', '', $rule);
        // Coupe la chaîne au niveau de l'opérateur
        $operands = explode ("+", $rule);
        // Nombre d'opérande
        $nb_operands = count($operands);

        // Règle à null
        if ($rule == "null") {
            return null;
        }

        // Si c'est une règle spécifique
        if ($rule_name == "regle_autorite_competente"
            || $rule_name == "regle_etat"
            || $rule_name == "regle_accord_tacite"
            || $rule_name == "regle_avis") {
            //
            return $this->valF[$rule];
        }

        // Tableau des champs de type date
        $rule_type_date = array(
            "regle_date_limite",
            "regle_date_notification_delai",
            "regle_date_complet",
            "regle_date_validite",
            "regle_date_decision",
            "regle_date_chantier",
            "regle_date_achevement",
            "regle_date_conformite",
            "regle_date_rejet",
            "regle_date_dernier_depot",
            "regle_date_limite_incompletude",
        );
        // Tableau des champs de type numérique
        $rule_type_numeric = array(
            "regle_delai",
            "regle_delai_incompletude",
        );

        // Définit le type du champ
        if (in_array($rule_name, $rule_type_date) == true) {
            $type = "date";
        }
        if (in_array($rule_name, $rule_type_numeric) == true) {
            $type = "numeric";
        }

        // Initialisation des variables
        $key_date = 0;
        $total_numeric = 0;

        // Pour chaque opérande
        foreach ($operands as $key => $operand) {

            // Si c'est une règle de type date
            if ($type == 'date') {
                // Vérifie si au moins une des opérandes est une date
                if (!is_numeric($operand)
                    && isset($this->valF[$operand])
                    && $this->f->check_date($this->valF[$operand]) == true) {
                    // Récupère la position de la date
                    $key_date = $key;
                }
                // Les autres opérandes doivent être que des numériques
                if (is_numeric($operand) == true) {
                    // Ajoute l'opérande au total
                    $total_numeric += $operand;
                }
                if (!is_numeric($operand)
                    && isset($this->valF[$operand])
                    && is_numeric($this->valF[$operand]) == true) {
                    // Ajoute l'opérande au total
                    $total_numeric += $this->valF[$operand];
                }
            }

            // Si c'est une règle de type numérique
            if ($type == 'numeric') {
                // Les opérandes doivent être que des numériques
                if (is_numeric($operand) == true) {
                    // Ajoute l'opérande au total
                    $total_numeric += $operand;
                }
                if (!is_numeric($operand)
                    && isset($this->valF[$operand])
                    && is_numeric($this->valF[$operand]) == true) {
                    // Ajoute l'opérande au total
                    $total_numeric += $this->valF[$operand];
                }
            }
        }

        // Résultat pour une règle de type date
        if ($type == 'date') {
            // Retourne le calcul de la date
            return $this->f->mois_date($this->valF[$operands[$key_date]], 
                $total_numeric, "+");
        }

        // Résultat pour une règle de type numérique
        if ($type == 'numeric') {
            // Retourne le calcul 
            return $total_numeric;
        }
        
    }

    function triggerajouterapres($id,&$db,$val,$DEBUG) {
        /**
         * Mise à jour des valeurs du dossier en fonction des valeurs calculées
         * par l'action
         */
        $this->getValEvenement();
        // Initialisation
        $valF = "";
        // état de complétude actuel du dossier
        $incompletude =  $this->dossierIncomplet();

        if($incompletude === FALSE) {
            // Si l'événement d'instruction est de type incompletude
            if($this->valEvenement['type'] == "incompletude") {
                // On marque le dossier en incomplétude pour application des actions
                $incompletude = TRUE;
                // Set du flag incomplétude de la table dossier
                $valF['incompletude'] = TRUE;
                // Enregistrement de l'état dans la variable provisoire
                $valF['etat_pendant_incompletude'] = $this->valF['archive_etat'];
            }
        } else {
            // Si l'evenement d'instruction est de type retour ou contient une
            // decision, on sort d'incomplétude
            if($this->valEvenement['type'] == "retour" OR
               $this->valEvenement['avis_decision'] != NULL) {
                // On enlève la marque d'incomplétude pour application des actions
                $incompletude = FALSE;
                // On enlève le flag d'incomplétude sur l'enregistrement de la table dossier
                $valF['incompletude'] = FALSE;
                 // Restauration de l'état depuis l'état provisoire
                $valF['etat'] = $this->valF['archive_etat_pendant_incompletude'];
                // On vide la variable provisoire ainsi que le délai de complétude
                // et la date limite de complétude
                $valF['etat_pendant_incompletude'] = NULL;
                $valF['delai_incompletude'] = NULL;
                $valF['date_limite_incompletude'] = NULL;
            }
        }
        // Récupération des paramètres de l'action
        $sql = "SELECT * FROM ".DB_PREFIXE."action
        WHERE action='".$this->valF['action']."'";
        $res = $db->query($sql);
        $this->addToLog("triggerajouterapres(): db->query(\"".$sql."\");", VERBOSE_MODE);
        if (database::isError($res)) {
            die($res->getMessage());
        }
        while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {

            // pour chacune des regles, on applique la regle
            if($row['regle_delai']!=''){
                $valF['delai'] = $this->regle($row['regle_delai'], 'regle_delai');
            }
            if($row['regle_accord_tacite']!=''){
                $valF['accord_tacite'] = $this->regle($row['regle_accord_tacite'], 'regle_accord_tacite');
            }
            if($row['regle_avis']!=''){
                $valF['avis_decision'] = $this->regle($row['regle_avis'], 'regle_avis');
            }
            if($row['regle_date_limite']!=''){
                $valF['date_limite']= $this->regle($row['regle_date_limite'], 'regle_date_limite');
            }
            if($row['regle_date_complet']!=''){
                $valF['date_complet']= $this->regle($row['regle_date_complet'], 'regle_date_complet');
            }
            if($row['regle_date_dernier_depot']!=''){
                $valF['date_dernier_depot']= $this->regle($row['regle_date_dernier_depot'], 'regle_date_dernier_depot');
            }
            if($row['regle_date_notification_delai']!=''){
                $valF['date_notification_delai']= $this->regle($row['regle_date_notification_delai'], 'regle_date_notification_delai');
            }
            if($row['regle_date_decision']!=''){
                $valF['date_decision']= $this->regle($row['regle_date_decision'], 'regle_date_decision');
            }
            if($row['regle_date_rejet']!=''){
                $valF['date_rejet']= $this->regle($row['regle_date_rejet'], 'regle_date_rejet');
            }
            if($row['regle_date_validite']!=''){
                $valF['date_validite']= $this->regle($row['regle_date_validite'], 'regle_date_validite');
            }
            if($row['regle_date_chantier']!=''){
                $valF['date_chantier']= $this->regle($row['regle_date_chantier'], 'regle_date_chantier');
            }
            if($row['regle_date_achevement']!=''){
                $valF['date_achevement']= $this->regle($row['regle_date_achevement'], 'regle_date_achevement');
            }
            if($row['regle_date_conformite']!=''){
                $valF['date_conformite']= $this->regle($row['regle_date_conformite'], 'regle_date_conformite');
            }
            if($row['regle_date_limite_incompletude']!=''){
                $valF['date_limite_incompletude']= $this->regle($row['regle_date_limite_incompletude'], 'regle_date_limite_incompletude');
            }
            if($row['regle_delai_incompletude']!=''){
                $valF['delai_incompletude']= $this->regle($row['regle_delai_incompletude'], 'regle_delai_incompletude');
            }
            if($row['regle_autorite_competente']!=''){
                $valF['autorite_competente']= $this->regle($row['regle_autorite_competente'], 'regle_autorite_competente');
            }
            if($row['regle_etat']!=''){
                // Si on est dans le cas général ou qu'on est en incomplétude et
                // qu'on a un événement de type incomplétude alors : on stocke
                // l'état dans la variable courante
                if ($incompletude == FALSE OR $this->valEvenement['type'] == "incompletude") {
                    $valF['etat'] = $this->regle($row['regle_etat'], 'regle_etat');
                } else {
                    $valF['etat_pendant_incompletude'] = $this->regle($row['regle_etat'], 'regle_etat');
                }
            }
            if($this->valEvenement['evenement_suivant_tacite'] != '') {
                // Si on est pas en incomplétude on stocke l'événement tacite
                //de l'événement dans la variable courante
                if ($incompletude == FALSE) {
                    $valF['evenement_suivant_tacite'] = $this->valEvenement['evenement_suivant_tacite'];
                } else {
                    $valF['evenement_suivant_tacite_incompletude'] = $this->valEvenement['evenement_suivant_tacite'];
                }
            }
        }
        // Si des valeurs ont été calculées alors on met à jour l'enregistrement
        if ($valF != "") {
            // On met à jour le dossier
            $cle = " dossier='".$this->valF['dossier']."'";
            $res1 = $db->autoExecute(DB_PREFIXE.'dossier', $valF, DB_AUTOQUERY_UPDATE, $cle);
            $this->addToLog("triggerajouterapres(): db->autoexecute(\"".DB_PREFIXE."dossier\", ".print_r($valF, true).", DB_AUTOQUERY_UPDATE, \"".$cle."\");", VERBOSE_MODE);
            if (database::isError($res1)) {
                die($res->getMessage());
            }
            // Affichage d'informations à l'utilisateur
            $this->addToMessage(_('enregistrement')." ".$this->valF['dossier']." "._('table')." dossier [".$db->affectedRows()." "._('enregistrement')." "._('mis_a_jour')."]");
        }

        /**
         * REFERENTIEL ERP
         */
        // verification si envoi vers ERP est active
        if ($this->f->getParameter('option_erp') != "") {
            // la nature du dossier
            $nature_dossier = substr($this->idxformulaire,0,2);
            //
            $sql = "SELECT erp
            FROM ".DB_PREFIXE."dossier
            WHERE dossier='".$this->valF['dossier']."'";
            $dossier_erp = $this->db->getone($sql);
            $this->addToLog("triggerajouterapres(): db->getone(\"".$sql."\");", VERBOSE_MODE);
            if (database::isError($res)) {
                die($res->getMessage());
            }
            //
            $sql = "SELECT libelle
            FROM ".DB_PREFIXE."evenement
            WHERE evenement='".$this->valF['evenement']."'";
            $evenement_libelle = $this->db->getone($sql);
            $this->addToLog("triggerajouterapres(): db->getone(\"".$sql."\");", VERBOSE_MODE);
            if (database::isError($res)) {
                die($res->getMessage());
            }
            //
            if ($dossier_erp == 't') {
                // envoi du message en cas d'un PC qui est ERP et sur lequel un evenement
                // d'acceptation etait fait
                if ($nature_dossier ==
                        $this->f->getParameter('erp_evenement_accepter_dossier_PC')
                    && $this->valF['evenement'] ==
                        $this->f->getParameter('erp_evenement_accepter_sans_reserve')) {
                    $msgenque = new MessageEnqueuer();
                    $msgenque->setDossierInstructionIdentifier($this->valF['dossier']);
                    $msgenque->setDecision($evenement_libelle);
                    $msgenque->enqueueMessage($msgenque::$ERP_ARRETE_PC_EFFECTUE);
                }
                if ($this->valF['evenement'] ==
                        $this->f->getParameter('erp_evenement_refuser_dossier')) {
                    $msgenque = new MessageEnqueuer();
                    $msgenque->setDossierInstructionIdentifier($this->valF['dossier']);
                    $msgenque->enqueueMessage($msgenque::$ERP_DECISION_CONFORMITE_EFFECTUE);                
                }
            }
        } // fin de if ($this->f->getParameter('option_erp') != "")

        // Mise à jour des données du dossier d'autorisation
        require_once "../obj/dossier_autorisation.class.php";
        $da = new dossier_autorisation($this->getNumDemandeAutorFromDossier($this->valF['dossier']), $this->db, DEBUG);
        $da->majDossierAutorisation();
    }    

    function triggermodifierapres($id,&$db,$val,$DEBUG) {
        /**
         * L'objectif ici est d'effectuer les recalculs de date dans le dossier
         * si la date de l'evenement est modifiee
         */ 
        // Initialisation
        $valF = "";
        // Initialisation du type d'événement
        $type_evmt = "";
        // Récupération de l'action correspondante à l'événement
        $sql = "SELECT action
        FROM ".DB_PREFIXE."evenement
        WHERE evenement=".$this->valF['evenement'];
        $action = $db->getOne($sql);
        $this->addToLog("triggermodifierapres(): db->getone(\"".$sql."\");", VERBOSE_MODE);
        if (database::isError($action)) {
            die($action->getMessage());
        }

        // Récupération des paramètres de l'action
        $sql = "SELECT * FROM ".DB_PREFIXE."action
        WHERE action='".$action."'";
        $res = $db->query($sql);
        $this->addToLog("triggermodifierapres(): db->query(\"".$sql."\");", VERBOSE_MODE);
        if (database::isError($res)) {
            die($res->getMessage());
        }
        while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)){
            // application des regles sur le courrier + delai
            if(preg_match("/date_evenement/",$row['regle_date_limite'])){
                $valF['date_limite']= $this->regle($row['regle_date_limite'], 'regle_date_limite');
            }
            if(preg_match("/date_evenement/",$row['regle_date_complet'])){
                $valF['date_complet']= $this->regle($row['regle_date_complet'], 'regle_date_complet');
            }
            if(preg_match("/date_evenement/",$row['regle_date_dernier_depot'])){
                $valF['date_dernier_depot']= $this->regle($row['regle_date_dernier_depot'], 'regle_date_dernier_depot');
            }
            if(preg_match("/date_evenement/",$row['regle_date_notification_delai'])){
                $valF['date_notification_delai']= $this->regle($row['regle_date_notification_delai'], 'regle_date_notification_delai');
            }
            if(preg_match("/date_evenement/",$row['regle_date_decision'])){
                $valF['date_decision']= $this->regle($row['regle_date_decision'], 'regle_date_decision');
            }
            if(preg_match("/date_evenement/",$row['regle_date_rejet'])){
                $valF['date_rejet']= $this->regle($row['regle_date_rejet'], 'regle_date_rejet');
            }
            if(preg_match("/date_evenement/",$row['regle_date_validite'])){
                $valF['date_validite']= $this->regle($row['regle_date_validite'], 'regle_date_validite');
            }
            if(preg_match("/date_evenement/",$row['regle_date_chantier'])){
                $valF['date_chantier']= $this->regle($row['regle_date_chantier'], 'regle_date_chantier');
            }
            if(preg_match("/date_evenement/",$row['regle_date_achevement'])){
                $valF['date_achevement']= $this->regle($row['regle_date_achevement'], 'regle_date_achevement');
            }
            if(preg_match("/date_evenement/",$row['regle_date_conformite'])){
                $valF['date_conformite']= $this->regle($row['regle_date_conformite'], 'regle_date_conformite');
            }
        }
        // Si des valeurs ont été calculées alors on met à jour l'enregistrement
        if ($valF != "") {
            // On met à jour le dossier
            $cle = " dossier='".$this->valF['dossier']."'";
            $res1 = $db->autoExecute(DB_PREFIXE.'dossier', $valF, DB_AUTOQUERY_UPDATE, $cle);
            $this->addToLog("triggermodifierapres(): db->autoexecute(\"".DB_PREFIXE."dossier\", ".print_r($valF, true).", DB_AUTOQUERY_UPDATE, \"".$cle."\");", VERBOSE_MODE);
            if (database::isError($res1)) {
                die($res->getMessage());
            }
            // Affichage d'informations à l'utilisateur
            $this->addToMessage(_('enregistrement')." ".$this->valF['dossier']." "._('table')." dossier [".$db->affectedRows()." "._('enregistrement')." "._('mis_a_jour')."]");
        }

        // Récupération de tous les paramètres de l'événement sélectionné
        $sql = "SELECT * FROM ".DB_PREFIXE."evenement
        WHERE evenement=".$this->valF['evenement'];
        $res = $db->query($sql);
        $this->addToLog("triggermodifierapres(): db->query(\"".$sql."\");", VERBOSE_MODE);
        if (database::isError($res)) {
            die($res->getMessage());
        }
        while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
            // Si la date de retour signature est éditée on vérifie si il existe un événement automatique
            if ($this->getVal('date_retour_signature') == "" AND 
                $this->valF['date_retour_signature'] != "" AND
                $row['evenement_retour_signature'] != "") {
                $new_instruction = new instruction("]", $db, $DEBUG);
                // Création d'un tableau avec la liste des champs de l'instruction
                foreach($new_instruction->champs as $champ) {
                    $valNewInstr[$champ] = ""; 
                }
                // Définition des valeurs de la nouvelle instruction
                $valNewInstr["evenement"] = $row['evenement_retour_signature'];
                $valNewInstr["destinataire"] = $this->valF['destinataire'];
                $valNewInstr["dossier"] = $this->valF['dossier'];
                $valNewInstr["date_evenement"] = $this->f->formatDate($this->valF['date_retour_signature']);
                $valNewInstr["date_envoi_signature"] = $this->f->formatDate($this->valF['date_envoi_signature']);
                $valNewInstr["date_retour_signature"] = $this->f->formatDate($this->valF['date_retour_signature']);
                $valNewInstr["date_envoi_rar"] = $this->f->formatDate($this->valF['date_envoi_rar']);
                $valNewInstr["date_retour_rar"] = $this->f->formatDate($this->valF['date_retour_rar']);
                $valNewInstr["date_envoi_controle_legalite"] = $this->f->formatDate($this->valF['date_envoi_controle_legalite']);
                $valNewInstr["date_retour_controle_legalite"] = $this->f->formatDate($this->valF['date_retour_controle_legalite']);
                $new_instruction->ajouter($valNewInstr,$db, $DEBUG);
            }
            // Si la date de retour AR est éditée on vérifie si il existe un événement automatique
            if ($this->getVal('date_retour_rar') == "" AND 
                $this->valF['date_retour_rar'] != "" AND
                $row['evenement_retour_ar'] != "" ) {
                $new_instruction = new instruction("]", $db, $DEBUG);
                // Création d'un tableau avec la liste des champs de l'instruction
                foreach($new_instruction->champs as $champ) {
                    $valNewInstr[$champ] = ""; 
                }
                // Définition des valeurs de la nouvelle instruction
                $valNewInstr["evenement"] = $row['evenement_retour_ar'];
                $valNewInstr["destinataire"] = $this->valF['destinataire'];
                $valNewInstr["dossier"] = $this->valF['dossier'];
                $valNewInstr["date_evenement"] = $this->f->formatDate($this->valF['date_retour_rar']);
                $valNewInstr["date_envoi_signature"] = $this->f->formatDate($this->valF['date_envoi_signature']);
                $valNewInstr["date_retour_signature"] = $this->f->formatDate($this->valF['date_retour_signature']);
                $valNewInstr["date_envoi_rar"] = $this->f->formatDate($this->valF['date_envoi_rar']);
                $valNewInstr["date_retour_rar"] = $this->f->formatDate($this->valF['date_retour_rar']);
                $valNewInstr["date_envoi_controle_legalite"] = $this->f->formatDate($this->valF['date_envoi_controle_legalite']);
                $valNewInstr["date_retour_controle_legalite"] = $this->f->formatDate($this->valF['date_retour_controle_legalite']);
                $new_instruction->ajouter($valNewInstr,$db, $DEBUG);
            }
        }

        /**
         * REFERENTIEL ARRETE
         */
        // Si l'option référentiel arrêté est activé et l'événement est de type
        // arrêté
        if ($this->f->getParameter('option_referentiel_arrete') != "" AND
            $type_evmt == "arrete") {
            if ($this->valF['date_retour_signature'] != $this->getVal('date_retour_signature')) {
                $msgenque = new MessageEnqueuer();
                $sqlArrete = "SELECT instruction.signataire_arrete as \"ws_DA_In_Signataire\",
                                    signataire_arrete.nom as \"ws_DA_In_Sign_Nom\",
                                    signataire_arrete.prenom as \"ws_DA_In_Sign_Prenom\",
                                    signataire_arrete.qualite as \"ws_DA_In_Sign_Qualite\",
                                    instruction.date_evenement as \"ws_DA_In_Dte_Redac\",
                                    '' as \"ws_DA_In_lieu_Redac\",
                                    instruction.dossier as \"ws_DA_In_N_Doss_DAS\",
                                    '' as \"ws_DA_In_Sigle\",
                                    instruction.etat as \"ws_DA_In_Decision\",
                                    dossier.date_depot as \"ws_DA_In_Dte_Depot_Dem\",
                                    dossier.terrain_adresse_voie_numero as \"ws_DA_In_N_Voie\",
                                    '' as \"ws_DA_In_Type_Voie\",
                                    dossier.terrain_adresse_voie as \"ws_DA_In_Adresse1\",
                                    dossier.terrain_adresse_lieu_dit as \"ws_DA_In_Adresse2\",
                                    dossier.terrain_adresse_code_postal as \"ws_DA_In_CP\",
                                    dossier.terrain_adresse_localite as \"ws_DA_In_Ville\",
                                    dossier.terrain_references_cadastrales as \"ws_DA_In_Nb_Parcelle\",
                                    '' as \"ws_DA_In_Detail_Parcelle\",
                                    CONCAT(donnees_techniques.am_projet_desc,' ',donnees_techniques.co_projet_desc) as \"ws_DA_In_Nature_Trvx\",
                                    '' as \"ws_DA_In_Destination_Trvx\",
                                    dossier_autorisation_type_detaille.code as \"ws_DA_In_Type_Dos_Autoris\",
                                    COALESCE(particulier_nom,personne_morale_raison_sociale) as \"ws_DA_In_Nom_Petition\",
                                    COALESCE(particulier_prenom, personne_morale_denomination) as \"ws_DA_In_Prenom_Petition\",
                                    '' as \"ws_DA_In_Piece_GED\",
                                    instruction.date_retour_signature as \"ws_DA_In_Dte_Signature\"
                            FROM ".DB_PREFIXE."instruction
                            LEFT JOIN ".DB_PREFIXE."signataire_arrete ON
                                instruction.signataire_arrete = signataire_arrete.signataire_arrete
                            LEFT JOIN ".DB_PREFIXE."dossier ON
                                instruction.dossier = dossier.dossier
                            LEFT JOIN ".DB_PREFIXE."lien_dossier_demandeur ON
                                lien_dossier_demandeur.dossier = dossier.dossier
                            LEFT JOIN ".DB_PREFIXE."demandeur ON
                                lien_dossier_demandeur.demandeur = demandeur.demandeur
                            LEFT JOIN ".DB_PREFIXE."dossier_instruction_type ON
                                dossier.dossier_instruction_type = dossier_instruction_type.dossier_instruction_type
                            LEFT JOIN ".DB_PREFIXE."dossier_autorisation_type_detaille ON
                                dossier_instruction_type.dossier_autorisation_type_detaille =
                                    dossier_autorisation_type_detaille.dossier_autorisation_type_detaille
                            LEFT JOIN ".DB_PREFIXE."donnees_techniques ON
                                    donnees_techniques.dossier_instruction = dossier.dossier
                            WHERE instruction.instruction = ".$this->valF['instruction'];
                $resArrete = $this->db->query($sqlArrete);
                $this->f->addToLog("triggermodifierapres(): db->query(\"".$sqlArrete."\");", VERBOSE_MODE);
                if ( database::isError($resArrete)){
                    die();
                }
    
                $rowArrete = $resArrete->fetchRow(DB_FETCHMODE_ASSOC);
                $msgenque->setArreteInfo($rowArrete);
                $msgenque->enqueueMessage($msgenque::$ARRETE_ENVOI);                
            }
        }

        // Mise à jour des données du dossier d'autorisation
        require_once "../obj/dossier_autorisation.class.php";
        $da = new dossier_autorisation($this->getNumDemandeAutorFromDossier($this->valF['dossier']), $this->db, DEBUG);
        $da->majDossierAutorisation();
    } 

    function triggersupprimer($id,&$db,$val,$DEBUG) {
        /**
         * L'objectif ici est de repositionner les valeurs récupérées en
         * archive dans le dossier d'instruction avant de supprimer l'événement
         * d'instruction
         */
         
            // Mise à jour des 4 valeurs modifiées par l'action
            $valF['delai'] = $val['archive_delai'];
            $valF['accord_tacite'] = $val['archive_accord_tacite'];
            $valF['etat'] = $val['archive_etat'];
            if ($val['archive_avis'] != '') {
                $valF['avis_decision'] = $val['archive_avis'];
            } else {
                $valF['avis_decision'] = NULL;
            }
            // Mise à jour des 10 dates avec la valeur présente dans le formulaire
            // de suppression. Si la valeur de la date est vide alors on fixe
            // à la valeur NULL
            //
            if ($val['archive_date_complet'] != '') {
                $valF['date_complet'] = $val['archive_date_complet'];
            } else {
                $valF['date_complet'] = NULL;
            }
            if ($val['archive_date_dernier_depot'] != '') {
                $valF['date_dernier_depot'] = $val['archive_date_dernier_depot'];
            } else {
                $valF['date_dernier_depot'] = NULL;
            }
            if ($val['archive_date_rejet'] != '') {
                $valF['date_rejet'] = $val['archive_date_rejet'];
            } else {
                $valF['date_rejet'] = NULL;
            }
            if ($val['archive_date_limite'] != '') {
                $valF['date_limite'] = $val['archive_date_limite'];
            } else {
                $valF['date_limite'] = NULL;
            }
            if ($val['archive_date_notification_delai'] != '') {
                $valF['date_notification_delai'] = $val['archive_date_notification_delai'];
            } else {
                $valF['date_notification_delai'] = NULL;
            }
            if ($val['archive_date_decision'] != '') { 
                $valF['date_decision'] = $val['archive_date_decision'];
            } else {
                $valF['date_decision'] = NULL;
            }
            if ($val['archive_date_validite'] != '') {
                $valF['date_validite'] = $val['archive_date_validite'];
            } else {
                $valF['date_validite'] = NULL;
            }
            if ($val['archive_date_achevement'] != '') {
                $valF['date_achevement'] = $val['archive_date_achevement'];
            } else {
                $valF['date_achevement'] = NULL;
            }
            if ($val['archive_date_chantier'] != '') {
                $valF['date_chantier'] = $val['archive_date_chantier'];
            } else {
                $valF['date_chantier'] = NULL;
            }
            if ($val['archive_date_conformite'] != '') {
                $valF['date_conformite'] = $val['archive_date_conformite'];
            } else {
                $valF['date_conformite'] = NULL;
            }
            if ($val['archive_incompletude'] != '') {
                $valF['incompletude'] = $val['archive_incompletude'];
            } else {
                $valF['incompletude'] = NULL;
            }
            if ($val['archive_evenement_suivant_tacite'] != '') {
                $valF['evenement_suivant_tacite'] = $val['archive_evenement_suivant_tacite'];
            } else {
                $valF['evenement_suivant_tacite'] = NULL;
            }
            if ($val['archive_evenement_suivant_tacite_incompletude'] != '') {
                $valF['evenement_suivant_tacite_incompletude'] = $val['archive_evenement_suivant_tacite_incompletude'];
            } else {
                $valF['evenement_suivant_tacite_incompletude'] = NULL;
            }
            if ($val['archive_etat_pendant_incompletude'] != '') {
                $valF['etat_pendant_incompletude'] = $val['archive_etat_pendant_incompletude'];
            } else {
                $valF['etat_pendant_incompletude'] = NULL;
            }
            if ($val['archive_date_limite_incompletude'] != '') {
                $valF['date_limite_incompletude'] = $val['archive_date_limite_incompletude'];
            } else {
                $valF['date_limite_incompletude'] = NULL;
            }
            if ($val['archive_delai_incompletude'] != '') {
                $valF['delai_incompletude'] = $val['archive_delai_incompletude'];
            } else {
                $valF['delai_incompletude'] = NULL;
            }
            if ($val['archive_autorite_competente'] != '') {
                $valF['autorite_competente'] = $val['archive_autorite_competente'];
            } else {
                $valF['autorite_competente'] = NULL;
            }
            // On met à jour le dossier
            $cle = " dossier='".$val['dossier']."'";
            $res = $db->autoExecute(DB_PREFIXE.'dossier', $valF, DB_AUTOQUERY_UPDATE, $cle);
            $this->addToLog("triggersupprimer(): db->autoexecute(\"".DB_PREFIXE."dossier\", ".print_r($valF, true).", DB_AUTOQUERY_UPDATE, \"".$cle."\");", VERBOSE_MODE);
            if (database::isError($res)) {
                die($res->getMessage());
            }
            // Affichage d'informations à l'utilisateur
            $this->addToMessage(_("Suppression de l'instruction")." [".$db->affectedRows()." "._('enregistrement')." "._('mis_a_jour')."]");
    
            // Mise à jour de la demande si un récépissé d'instruction correspond à l'instruction à supprimer
    }

    function triggersupprimerapres($id,&$db,$val,$DEBUG) {

        // Mise à jour des données du dossier d'autorisation
        require_once "../obj/dossier_autorisation.class.php";
        $da = new dossier_autorisation($this->getNumDemandeAutorFromDossier($val["dossier"]), $this->db, DEBUG);
        $da->majDossierAutorisation();
    }

    // Vérifie la restriction sur l'événement
    function verifier($val = array(), &$db, $DEBUG){
        parent::verifier($val, $db, $DEBUG);

        if ( isset($val['evenement']) && is_numeric($val['evenement'])){
            //Récupère la restriction
            $sql= "SELECT 
                      restriction 
                  FROM 
                      ".DB_PREFIXE."evenement 
                  WHERE 
                      evenement =".$val['evenement'];
    
            $res = $db->query($sql);
            $this->addToLog("verifier(): db->query(\"".$sql."\");", VERBOSE_MODE);
            if (database::isError($res)) {
                die($res->getMessage());
            }        
            $row=& $res->fetchRow(DB_FETCHMODE_ASSOC);
    
            //Test qu'une restriction est présente
            if ( isset($row['restriction']) && $row['restriction'] != "" ){

                $restriction = $row['restriction'];
                
                //Test si la restriction est valide
                if ( !$this->restrictionIsValid($restriction) ){
                    
                    $this->correct=false;
                    $this->addToMessage(_("Restriction non valide"));
                }
                else {
                    
                    $this->correct = true;
                }

                // Liste des opérateurs possible
                $operateurs = array(">=", "<=", "+", "-");

                // Supprime tous les espaces de la chaîne de caractère
                $restriction = str_replace(' ', '', $restriction);
                
                // Met des espace avant et après les opérateurs puis transforme la 
                // chaine en un tableau 
                $tabRestriction = str_replace($operateurs, " ", $restriction);
                // Tableau des champ
                $tabRestriction = explode(" ", $tabRestriction);
                // Supprime les numériques du tableau
                foreach ($tabRestriction as $key => $value) {
                    if (is_numeric($value)) {
                        unset($tabRestriction[$key]);
                    }
                }

                // Vérifie les champs utilisés pour la restriction
                $check_field_exist = $this->f->check_field_exist($tabRestriction, 'instruction');
                if ($check_field_exist !== true) {

                    // Liste des champs en erreur
                    $string_error_fields = implode(", ", $check_field_exist);

                    // Message d'erreur
                    $error_message = _("Le champ %s n'est pas utilisable pour le champ %s");
                    if (count($check_field_exist) > 1) {
                        $error_message = _("Les champs %s ne sont pas utilisable pour le champ %s");
                    }

                    // Affiche l'erreur
                    $this->correct=false;
                    $this->addToMessage(sprintf($error_message, $string_error_fields, _("restriction")));
                    $this->addToMessage(_("Veuillez contacter votre administrateur."));
                }
            }

        }
        if(!$this->updateDate("date_envoi_signature")) {
            return false;
        }
        if(!$this->updateDate("date_retour_signature")) {
            return false;
        }
        if(!$this->updateDate("date_envoi_rar")) {
            return false;
        }
        if(!$this->updateDate("date_retour_rar")) {
            return false;
        }
        if(!$this->updateDate("date_envoi_controle_legalite")) {
            return false;
        }
        if(!$this->updateDate("date_retour_controle_legalite")) {
            return false;
        }

    }

    /**
     * Méthode permettant de récupérer toutes les valeurs de l'événement
     * sélectionné après validation du formulaire d'instruction
     *
     * @return array() veleurs de l'événement lié
     */

    private function getValEvenement() {
        if(!empty($this->valEvenement)) {
            return $this->valEvenement;
        } else {
            $sql = "SELECT * FROM ".DB_PREFIXE."evenement
                WHERE evenement=".$this->valF['evenement'];
            $res = $this->db->query($sql);
            $this->addToLog("getValEvenement(): db->query(\"".$sql."\");", VERBOSE_MODE);
            if (database::isError($res)) {
                die($res->getMessage());
            }
            $this->valEvenement = $res->fetchRow(DB_FETCHMODE_ASSOC);
            return $this->valEvenement;
        }
    }

    /**
     * Méthode permettant de savoir si le dossier lié à l'instruction à le flag
     * incompletude à true après validation du formulaire d'instruction
     *
     * @return boolean 
     */
    private function dossierIncomplet() {
        $sql = "SELECT incompletude FROM ".DB_PREFIXE."dossier
                WHERE dossier='".$this->valF['dossier']."'";
        $incompletude = $this->db->getOne($sql);
        $this->addToLog("dossierIncomplet(): db->query(\"".$sql."\");", VERBOSE_MODE);
        if (database::isError($incompletude)) {
            die($incompletude->getMessage());
        }
        if ($incompletude == 't') {
            return true;
        } else {
            return false;
        }
    }
    
    /**
     * Finalisation des documents.
     * @param  string $champ    champ du fichier à finaliser
     * @param  booleen $status  permet de définir si on finalise ou définalise
     * @param  string $sousform permet de savoir si se trouve dans un sousformulaire (passé au javascript)
     */
    function finaliser( $champ = '', $status, $sousform, $retourformulaire){

        //Si on finalise le document
        if ( $status == 1 ){
            
            //Génération du PDF
            $_GET['output'] = "string";
            $f = $this->f;
            include '../app/pdf_instruction.php';
            
            //Métadonnées du document
            $metadata = array(
                'filename' => 'instruction_'.$idx.'.pdf',
                'mimetype' => 'application/pdf',
                'size' => strlen($pdf_output)
            );

            // Récupération des métadonnées calculées après validation
            $spe_metadata = $this->getMetadata("om_fichier_instruction");

            $metadata = array_merge($metadata, $spe_metadata);
            //Si le document a déjà été finalisé
            //on met à jour le document mais pas son uid
            if ( $this->getVal("om_fichier_instruction") != '' ){
                $uid = $this->f->storage->update(
                    $this->getVal("om_fichier_instruction"), $pdf_output, $metadata);
            }
            //Sinon, on joute le document et on récupère son uid
            else {
                //Stockage du PDF
                $uid = $this->f->storage->create($pdf_output, $metadata);
            }
        }
        else {
            //Récupération de l'uid du document finalisé
            $uid = $this->getVal("om_fichier_instruction");
            
            //On dé-finalise avant de finaliser
            if ( $uid == '' || $uid == 'OP_FAILURE' ){
                return -1;
            }
        }

        //Mise à jour des données
        if ( $uid != '' && $uid != 'OP_FAILURE' ){
            // Logger
            $this->addToLog("finaliser() - begin", EXTRA_VERBOSE_MODE);
            // Recuperation de la valeur de la cle primaire de l'objet
            if($this->getVal($this->clePrimaire) != '')
                $id = $this->getVal($this->clePrimaire);
            else
                $id=$this->id;
            
            $actions = array();
            //Tableau contenant le lien vers le PDF et lien du portlet pour la mise
            //à jour de l'interface
            if ( $status == 0 ){
                $lien = '../app/pdf_instruction.php?idx='.$id;
                
                //Ajout des actions
                //Si l'utilisateur a le droit de modifier l'objet
                if ( $this->f->isAccredited('instruction') || 
                    $this->f->isAccredited('instruction_modifier') ){
                        
                    $actions["modifier"] = ($sousform!='')?
                        '<li><a href="#" onclick="ajaxIt(\'instruction\',
                        \'../scr/sousform.php?obj=instruction&amp;action=1&amp;idx='.
                        $this->getVal($this->clePrimaire).
                        '&amp;premiersf=0&amp;trisf=&amp;retourformulaire='.$retourformulaire.'&amp;idxformulaire='.
                        $this->getVal("dossier").
                        '&amp;retour=form\');">
                        <span class="om-prev-icon om-icon-16 edit-16" title="'.
                        _('Modifier').'">'.
                        _('Modifier').
                        '</span></a></li>':
                        '<li>
                        <a href="form.php?obj=instruction&amp;action=1'.'&amp;idx='.
                        $this->getVal($this->clePrimaire).
                        '&amp;premier=&amp;advs_id=&amp;recherche=&amp;tricol=&amp;selectioncol=&amp;valide=&amp;retour=form">
                        <span class="om-prev-icon om-icon-16 edit-16" title="'.
                        _('Modifier').'">'.
                        _('Modifier').
                        '</span></a></li>';
                }
                //Si l'utilisateur a le droit de supprimer l'objet
                if ( $this->f->isAccredited('instruction') || 
                    $this->f->isAccredited('instruction_supprimer') ){
                        
                    $actions["supprimer"] = ($sousform!='')?
                        '<li><a href="#" onclick="ajaxIt(\'instruction\',
                        \'../scr/sousform.php?obj=instruction&amp;action=2&amp;idx='.
                        $this->getVal($this->clePrimaire).
                        '&amp;premiersf=0&amp;trisf=&amp;retourformulaire='.$retourformulaire.'&amp;idxformulaire='.
                        $this->getVal("dossier").
                        '&amp;retour=form\');">
                        <span class="om-prev-icon om-icon-16 delete-16" title="'.
                        _('Supprimer').'">'.
                        _('Supprimer').
                        '</span></a></li>':
                        '<li>
                        <a href="form.php?obj=instruction&amp;action=1'.'&amp;idx='.
                        $this->getVal($this->clePrimaire).
                        '&amp;premier=&amp;advs_id=&amp;recherche=&amp;tricol=&amp;selectioncol=&amp;valide=&amp;retour=form">
                        <span class="om-prev-icon om-icon-16 delete-16" title="'.
                        _('Supprimer').'">'.
                        _('Supprimer').
                        '</span></a></li>';
                }
            }
            else { 
                $lien = '../spg/file.php?obj=instruction&'.
                    'champ=om_fichier_instruction&id='.$id;
            }

           $retour = array(
                "portlet"=> "<a href=\"#\" onclick=\"finalizeDocument(".
                    $id.", 'instruction', '".$sousform."', ".(($status==0)?1:0).")\">
                    <span class=\"om-prev-icon om-icon-16 om-icon-fix "
                    .(($status==1)?"de":"")."finalise\" title=\"".
                    (($status==1)?_("Reprendre la redaction du document"):_("Finaliser le document"))."\">".
                    (($status==1)?_("Reprendre la redaction du document"):_("Finaliser le document"))."</span>
                    </a>",
                "pdf" => $lien,
                "actions" => $actions
            );

            foreach ( $this->champs as $key=>$value )
                $val[$value] = $this->val[$key];
            $val['date_evenement']=$this->dateDBToForm($val['date_evenement']);
            $val['archive_date_complet']=$this->dateDBToForm($val['archive_date_complet']);
            $val['archive_date_rejet']=$this->dateDBToForm($val['archive_date_rejet']);
            $val['archive_date_limite']=$this->dateDBToForm($val['archive_date_limite']);
            $val['archive_date_notification_delai']=$this->dateDBToForm($val['archive_date_notification_delai']);
            $val['archive_date_decision']=$this->dateDBToForm($val['archive_date_decision']);
            $val['archive_date_validite']=$this->dateDBToForm($val['archive_date_validite']);
            $val['archive_date_achevement']=$this->dateDBToForm($val['archive_date_achevement']);
            $val['archive_date_chantier']=$this->dateDBToForm($val['archive_date_chantier']);
            $val['archive_date_conformite']=$this->dateDBToForm($val['archive_date_conformite']);
            $val['archive_date_dernier_depot']=$this->dateDBToForm($val['archive_date_dernier_depot']);
            $val['archive_date_limite_incompletude']=$this->dateDBToForm($val['archive_date_limite_incompletude']);
            $val['date_finalisation_courrier']=$this->dateDBToForm($val['date_finalisation_courrier']);
            $val['date_envoi_signature']=$this->dateDBToForm($val['date_envoi_signature']);
            $val['date_retour_signature']=$this->dateDBToForm($val['date_retour_signature']);
            $val['date_envoi_rar']=$this->dateDBToForm($val['date_envoi_rar']);
            $val['date_retour_rar']=$this->dateDBToForm($val['date_retour_rar']);
            $val['date_envoi_controle_legalite']=$this->dateDBToForm($val['date_envoi_controle_legalite']);
            $val['date_retour_controle_legalite']=$this->dateDBToForm($val['date_retour_controle_legalite']);
            
            $this->setvalF($val);

            // Verification de la validite des donnees
            $this->verifier($this->val, $this->db, DEBUG);
            // Verification du verrou
            $this->testverrou();
            // Si les verifications precedentes sont correctes, on procede a
            // la modification, sinon on ne fait rien et on retourne une erreur
            if ($this->correct) {
                // Execution du trigger 'before' specifique au MODE 'update'
                $this->triggermodifier( $id, $this->db, $this->val, DEBUG);
                $valF = array(
                        "om_final_instruction"=> ($status==1)?TRUE:FALSE,
                        "om_fichier_instruction"=>$uid,
                        "date_finalisation_courrier"=>date('Y-m-d'));
                // Execution de la requête de modification des donnees de l'attribut
                // valF de l'objet dans l'attribut table de l'objet
                $res = $this->db->autoExecute(DB_PREFIXE.$this->table, $valF, 
                    DB_AUTOQUERY_UPDATE, $this->getCle($id));
                 $this->addToLog("finaliser() : db->autoExecute(\"".DB_PREFIXE.$this->table."\", ".print_r($valF, true).", DB_AUTOQUERY_UPDATE, \"".$this->getCle($id)."\")", VERBOSE_MODE);
                // Si une erreur survient
                if (database::isError($res)) {
                    // Appel de la methode de recuperation des erreurs
                    $this->erreur_db($res->getDebugInfo(), $res->getMessage(), '');
                } else {
                    // Log
                    $this->addToLog(_("Requete executee"), VERBOSE_MODE);
                    // Log
                    $message = _("Enregistrement")."&nbsp;".$id."&nbsp;";
                    $message .= _("de la table")."&nbsp;\"".$this->table."\"&nbsp;";
                    $message .= "[&nbsp;".$this->db->affectedRows()."&nbsp;";
                    $message .= _("enregistrement(s) mis a jour")."&nbsp;]";
                    $this->addToLog($message, VERBOSE_MODE);
                    // Mise en place du verrou pour ne pas finaliser plusieurs fois
                    // le meme document
                    $this->verrouille();
                    // Execution du trigger 'after' specifique au MODE 'update'
                    //$this->triggermodifierapres($id, $this->db, $val, DEBUG);

                    return $retour;
                } 
            } else {
                // Message d'echec (saut d'une ligne supplementaire avant le
                // message pour qu'il soit mis en evidence)
                $this->addToLog(_("Finalisation non enregistree"));
                return -1;
            }
        }
        // Si le document n'a pas été stocké
        else{
            return -1;
        }
    }

    /**
     * Récupération du numéro de dossier d'instruction à ajouter aux métadonnées
     * @return string numéro de dossier d'instruction
     */
    protected function getDossier() {
        if(empty($this->specificMetadata)) {
            $this->getSpecificMetadata();
        }
        return $this->specificMetadata->dossier;
    }
    /**
     * Récupération la version du dossier d'instruction à ajouter aux métadonnées
     * @return int Version
     */
    protected function getDossierVersion() {
        if(empty($this->specificMetadata)) {
            $this->getSpecificMetadata();
        }
        return $this->specificMetadata->version;
    }
    /**
     * Récupération du numéro de dossier d'autorisation à ajouter aux métadonnées
     * @return string numéro de dossier d'autorisation
     */
    protected function getNumDemandeAutor() {
        if(empty($this->specificMetadata)) {
            $this->getSpecificMetadata();
        }
        return $this->specificMetadata->dossier_autorisation;
    }
    /**
     * Récupération de la date de demande initiale du dossier à ajouter aux métadonnées
     * @return date de la demande initiale
     */
    protected function getAnneemoisDemandeAutor() {
        if(empty($this->specificMetadata)) {
            $this->getSpecificMetadata();
        }
        return $this->specificMetadata->date_demande_initiale;
    }
    /**
     * Récupération du type de dossier d'instruction à ajouter aux métadonnées
     * @return string type du dossier d'instruction
     */
    protected function getTypeInstruction() {
        if(empty($this->specificMetadata)) {
            $this->getSpecificMetadata();
        }
        return $this->specificMetadata->dossier_instruction_type;
    }
    /**
     * Récupération du statut du dossier d'autorisation à ajouter aux métadonnées
     * @return string avis
     */
    protected function getStatutAutorisation() {
        if(empty($this->specificMetadata)) {
            $this->getSpecificMetadata();
        }
        return $this->specificMetadata->statut;
    }
    /**
     * Récupération du type de dossier d'autorisation à ajouter aux métadonnées
     * @return string type du dossier d'autorisation
     */
    protected function getTypeAutorisation() {
        if(empty($this->specificMetadata)) {
            $this->getSpecificMetadata();
        }
        return $this->specificMetadata->dossier_autorisation_type;
    }
    /**
     * Récupération de la date d'ajout de document à ajouter aux métadonnées
     * @return date de l'évènement
     */
    protected function getDateEvenementDocument() {
        return date("Y-m-d");
    }
    /**
     * Récupération du groupe d'instruction à ajouter aux métadonnées
     * @return string Groupe d'instruction
     */
    protected function getGroupeInstruction() {
        if(empty($this->specificMetadata)) {
            $this->getSpecificMetadata();
        }
        return $this->specificMetadata->groupe_instruction;
    }
    /**
     * Récupération du libellé du type du document à ajouter aux métadonnées
     * @return string Groupe d'instruction
     */
    protected function getTitle() {

        // Récupère le champ événement
        if (isset($this->valF["evenement"]) AND $this->valF["evenement"] != "") {
            $evenement = $this->valF["evenement"];
        } else {
            $evenement = $this->getVal("evenement");
        }

        // Requête sql
        $sql = "SELECT libelle FROM ".DB_PREFIXE."evenement
                WHERE evenement=".$evenement;
        $evenement_libelle = $this->db->getOne($sql);
        $this->addToLog("getTitle(): db->getOne(\"".$sql."\");", VERBOSE_MODE);
        if (database::isError($evenement_libelle)) {
            die();
        }

        // Retourne le libelle de l'événement
        return $evenement_libelle;
    }

    /**
     * Cette méthode permet de stocker en attribut toutes les métadonnées
     * nécessaire à l'ajout d'un document.
     */
    public function getSpecificMetadata() {
        if (isset($this->valF["dossier"]) AND $this->valF["dossier"] != "") {
            $dossier = $this->valF["dossier"];
        } else {
            $dossier = $this->getVal("dossier");
        }
        //Requête pour récupérer les informations essentiels sur le dossier d'instruction
        $sql = "SELECT dossier.dossier as dossier,
                        dossier_autorisation.dossier_autorisation as dossier_autorisation, 
                        to_char(dossier.date_demande, 'YYYY/MM') as date_demande_initiale,
                        dossier_instruction_type.code as dossier_instruction_type, 
                        etat_dossier_autorisation.libelle as statut,
                        dossier_autorisation_type.code as dossier_autorisation_type,
                        groupe.code as groupe_instruction
                FROM ".DB_PREFIXE."dossier 
                    LEFT JOIN ".DB_PREFIXE."dossier_instruction_type  
                        ON dossier.dossier_instruction_type = dossier_instruction_type.dossier_instruction_type
                    LEFT JOIN ".DB_PREFIXE."dossier_autorisation 
                        ON dossier.dossier_autorisation = dossier_autorisation.dossier_autorisation 
                    LEFT JOIN ".DB_PREFIXE."etat_dossier_autorisation
                        ON  dossier_autorisation.etat_dossier_autorisation = etat_dossier_autorisation.etat_dossier_autorisation
                    LEFT JOIN ".DB_PREFIXE."dossier_autorisation_type_detaille
                        ON dossier_autorisation.dossier_autorisation_type_detaille = dossier_autorisation_type_detaille.dossier_autorisation_type_detaille
                    LEFT JOIN ".DB_PREFIXE."dossier_autorisation_type
                        ON dossier_autorisation_type_detaille.dossier_autorisation_type = dossier_autorisation_type.dossier_autorisation_type
                    LEFT JOIN ".DB_PREFIXE."groupe
                        ON dossier_autorisation_type.groupe = groupe.groupe
                WHERE dossier.dossier = '".$dossier."'";
        $res = $this->db->query($sql);
        $this->f->addToLog("getSpecificMetadata() : db->query(".$sql.")", VERBOSE_MODE);
        if ( database::isError($res)){
            die();
        }
        
        //Le résultat est récupéré dans un objet
        $row =& $res->fetchRow(DB_FETCHMODE_OBJECT);

        //Si il y a un résultat
        if ($row !== null) {
                
            //Génération du numéro de version
            $sql = "SELECT 
                        count(*) 
                FROM 
                    ".DB_PREFIXE."dossier
                LEFT JOIN
                    ".DB_PREFIXE."dossier_autorisation
                    ON
                        dossier_autorisation.dossier_autorisation = dossier.dossier_autorisation
                LEFT JOIN
                    ".DB_PREFIXE."dossier_instruction_type
                    ON
                        dossier_instruction_type.dossier_instruction_type = dossier.dossier_instruction_type
                WHERE
                    dossier_autorisation.dossier_autorisation = '".$row->dossier_autorisation."'
                    AND
                    dossier_instruction_type.code = '".$row->dossier_instruction_type."'";
            $row->version = $this->db->getOne($sql);
            $this->f->addToLog("getSpecificMetadata(): db->getOne(\"".$sql."\")", VERBOSE_MODE);
            if ( database::isError($row->version)){
                $this->f->addToError("", $row->version, $row->version);
                return false;
            }
            
            //Formatage du numéro de version
            $row->version = str_pad($row->version, 2, "0", STR_PAD_LEFT);

            //Alors on créé l'objet dossier_instruction
            $this->specificMetadata = $row;

        }
    }
    
    /**
     * Retourne le statut du dossier d'instruction
     * @param string $idx Identifiant du dossier d'instruction
     * @return string Le statut du dossier d'instruction
     */
    function getStatutAutorisationDossier($idx){
        
        $statut = '';
        
        //Si l'identifiant du dossier d'instruction fourni est correct
        if ( $idx != '' ){
            
            //On récupère le statut de l'état du dossier à partir de l'identifiant du
            //dossier
            $sql = "SELECT etat.statut
                FROM ".DB_PREFIXE."dossier
                LEFT JOIN
                    ".DB_PREFIXE."etat
                    ON
                        dossier.etat = etat.etat
                WHERE dossier ='".$idx."'";
            $statut = $this->db->getOne($sql);
            $this->f->addToLog("getStatutAutorisationDossier() : db->getOne(\"".$sql."\")", VERBOSE_MODE);
            if ( database::isError($statut)){
                die();
            }
        }
        return $statut;
    }

    /**
     * Récupère les données du dossier
     * @return array
     */
    function get_dossier_actual() {

        // Initialisation de la valeur de retour
        $return = array();

        // Récupération de toutes les valeurs du dossier d'instruction en cours
        $sql = "SELECT * FROM ".DB_PREFIXE."dossier
        WHERE dossier='".$this->valF['dossier']."'";
        $res = $this->db->query($sql);
        $this->addToLog("get_dossier_actual(): db->query(\"".$sql."\");", VERBOSE_MODE);
        $this->f->isDatabaseError($res);

        //
        while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {

            // Récupération de la valeur actuelle du délai, de l'accord tacite,
            // de l'état et de l'avis du dossier d'instruction
            $return['archive_delai']=$row['delai'];
            $return['archive_accord_tacite']=$row['accord_tacite'];
            $return['archive_etat']=$row['etat'];
            $return['archive_avis']=$row['avis_decision'];
            // Récupération de la valeur actuelle des 9 dates du dossier
            // d'instruction
            $return['archive_date_complet']=$row['date_complet'];
            $return['archive_date_dernier_depot']=$row['date_dernier_depot'];
            $return['archive_date_rejet']= $row['date_rejet'];
            $return['archive_date_limite']= $row['date_limite'];
            $return['archive_date_notification_delai']= $row['date_notification_delai'];
            $return['archive_date_decision']= $row['date_decision'];
            $return['archive_date_validite']= $row['date_validite'];
            $return['archive_date_achevement']= $row['date_achevement'];
            $return['archive_date_chantier']= $row['date_chantier'];
            $return['archive_date_conformite']= $row['date_conformite'];  
            $return['archive_incompletude']= $row['incompletude'];  
            $return['archive_evenement_suivant_tacite']= $row['evenement_suivant_tacite'];  
            $return['archive_evenement_suivant_tacite_incompletude']= $row['evenement_suivant_tacite_incompletude'];  
            $return['archive_etat_pendant_incompletude']= $row['etat_pendant_incompletude'];  
            $return['archive_date_limite_incompletude']= $row['date_limite_incompletude'];  
            $return['archive_delai_incompletude']= $row['delai_incompletude'];  
            $return['archive_autorite_competente']= $row['autorite_competente'];  
            $return['duree_validite']= $row['duree_validite'];  
        }

        // Retour de la fonction
        return $return;

    }

    /**
     * Permet de vérifier qu'un événement est verrouillable
     * @param  integer $idx     Identifiant de l'instruction
     * @return boolean          
     */
    function checkEvenementNonVerrouillable($idx) {

        // Initialisation du résultat
        $non_verrouillable = false;

        // Si la condition n'est pas vide
        if ($idx != "") {

            // Requête SQL
            $sql = "SELECT evenement.non_verrouillable
                    FROM ".DB_PREFIXE."evenement
                    LEFT JOIN ".DB_PREFIXE."instruction
                        ON instruction.evenement = evenement.evenement
                    WHERE instruction.instruction = $idx";
            $this->f->addToLog("checkEvenementNonVerrouillable() : db->getOne(\"".$sql."\")", VERBOSE_MODE);
            $res = $this->db->getOne($sql);
            $this->f->isDatabaseError($res);

            // Si le retour de la requête est true
            if ($res == 't') {
                // 
                $non_verrouillable = true;
            }
        }

        // Retourne résultat
        return $non_verrouillable;
    }
    
    /**
     * Mise à jour des champs archive_*
     * @param mixed $row La ligne de données
     */
    public function updateArchiveData($row){
        
        // Récupération de la valeur actuelle du délai, de l'accord tacite,
        // de l'état et de l'avis du dossier d'instruction
        $this->valF['archive_delai']=$row['delai'];
        $this->valF['archive_accord_tacite']=$row['accord_tacite'];
        $this->valF['archive_etat']=$row['etat'];
        $this->valF['archive_avis']=$row['avis_decision'];
        // Récupération de la valeur actuelle des 9 dates du dossier
        // d'instruction
        if ($row['date_complet'] != '') {
            $this->valF['archive_date_complet']=$row['date_complet'];
        }
        if ($row['date_dernier_depot'] != '') {
            $this->valF['archive_date_dernier_depot']=$row['date_dernier_depot'];
        }
        if ($row['date_rejet']!='') {
            $this->valF['archive_date_rejet']= $row['date_rejet'];
        }
        if ($row['date_limite']!='') {
            $this->valF['archive_date_limite']= $row['date_limite'];
        }
        if ($row['date_notification_delai']!='') {
            $this->valF['archive_date_notification_delai']= $row['date_notification_delai'];
        }
        if ($row['date_decision']!='') {
            $this->valF['archive_date_decision']= $row['date_decision'];
        }
        if ($row['date_validite']!='') {
            $this->valF['archive_date_validite']= $row['date_validite'];
        }
        if ($row['date_achevement']!='') {
            $this->valF['archive_date_achevement']= $row['date_achevement'];
        }
        if ($row['date_chantier']!='') {
            $this->valF['archive_date_chantier']= $row['date_chantier'];
        }
        if ($row['date_conformite']!='') {
            $this->valF['archive_date_conformite']= $row['date_conformite'];  
        }
        if ($row['incompletude']!='') {
            $this->valF['archive_incompletude']= $row['incompletude'];  
        }
        if ($row['evenement_suivant_tacite']!='') {
            $this->valF['archive_evenement_suivant_tacite']= $row['evenement_suivant_tacite'];  
        }
        if ($row['evenement_suivant_tacite_incompletude']!='') {
            $this->valF['archive_evenement_suivant_tacite_incompletude']= $row['evenement_suivant_tacite_incompletude'];  
        }
        if ($row['etat_pendant_incompletude']!='') {
            $this->valF['archive_etat_pendant_incompletude']= $row['etat_pendant_incompletude'];  
        }
        if ($row['date_limite_incompletude']!='') {
            $this->valF['archive_date_limite_incompletude']= $row['date_limite_incompletude'];  
        }
        if ($row['delai_incompletude']!='') {
            $this->valF['archive_delai_incompletude']= $row['delai_incompletude'];  
        }
        if ($row['autorite_competente']!='') {
            $this->valF['archive_autorite_competente']= $row['autorite_competente'];  
        }
        if ($row['duree_validite']!='') {
            $this->valF['duree_validite']= $row['duree_validite'];  
        }
    }
}// fin classe
?>