trunk/obj/dossier_autorisation.class.php

<?php
//$Id$ 
//gen openMairie le 14/11/2012 12:54

require_once ("../gen/obj/dossier_autorisation.class.php");

class dossier_autorisation extends dossier_autorisation_gen {


    var $valIdDemandeur = array("petitionnaire_principal" => "",
                                "delegataire" => "",
                                "petitionnaire" => array());

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


    /**
     *  Assure que la date passee par reference soit en
     *  format attendu par la fonction dateDB du fichier 
     *  core/om_dbform.class.php. Change le format de la
     *  date si necessaire.
     *  @param $string $field Le date dans format DB, ou
     *  celui attendu par setvalF
     */
    private function changeDateFormat(&$field) {
        if (preg_match('/([0-9]{4})-([0-9]{2})-([0-9]{2})/',
                    $field, $matches)) {
            $field = $matches[3].'/'.$matches[2].'/'.$matches[1];
        }        
    }
    
    function setvalF($val) {
        // verifie que les dates envoyes au parent::setvalF sont ont
        // bon format, et change le format si necessaire
        $this->changeDateFormat($val['erp_date_ouverture']);
        $this->changeDateFormat($val['erp_date_arrete_decision']);
        
        parent::setvalF($val);
        
        // si la valeur d'erp_arrete_decision n'etait pas set, laisse elle a null
        if ($val['erp_arrete_decision'] == null) {
            $this->valF['erp_arrete_decision'] = null;
        }
        // si la valeur d'erp_ouvert n'etait pas set, laisse elle a null
        if ($val['erp_ouvert'] == null) {
            $this->valF['erp_ouvert'] = null;
        }
    }

    /**
     * Méthode permettant de définir des valeurs à envoyer en base après
     * validation du formulaire d'ajout.
     * @param array $val tableau des valeurs retournées par le formulaire
     */
    function setValFAjout($val) {

        // Récupération du type de dossier ou série
        $sql = "SELECT da_t.code
        FROM ".DB_PREFIXE."dossier_autorisation_type as da_t
        INNER JOIN ".DB_PREFIXE."dossier_autorisation_type_detaille as da_t_d
        ON da_t.dossier_autorisation_type=da_t_d.dossier_autorisation_type
        WHERE da_t_d.dossier_autorisation_type_detaille=".
        $val['dossier_autorisation_type_detaille'].";";
        //
        $da_type_code = $this->db->getone($sql);
        $this->addToLog("setValFAjout(): db->getone(\"".$sql."\")", VERBOSE_MODE);
        database::isError($da_type_code);
        // Récupération du code département
        $departement = $this->f->getParameter("departement");
        // Récupération du code commune
        $commune = $this->f->getParameter("commune");
        // Récupération du numéro du dossier
        $numero_dossier = $this->createNumeroDossier($da_type_code);
        if($numero_dossier === false) {
            return false;
        }
        $annee = date('y', strtotime($val["depot_initial"]));
        /// IDENTIFIANT DU DOSSIER
        // PC 013 055 12 00001       
        $this->valF[$this->clePrimaire] =
            $da_type_code.$departement.$commune.$annee.$numero_dossier;

        // Identifiant du dossier d'autorisation lisible
        // Ex : DP 013055 13 00002
        $this->valF["dossier_autorisation_libelle"] = 
            $da_type_code." ".$departement.$commune." ".$annee." ".$numero_dossier;

    }

    // {{{
    // getter
    function getValIdDemandeur() {
        return $this->valIdDemandeur;
    }
    // setter
    function setValIdDemandeur($valIdDemandeur) {
        $this->valIdDemandeur = $valIdDemandeur;
    }
    // }}}
    
    /**
     * Créée une numérotation pour le dossier à partir d'un numéro dans un séquence
     * définie par le code du dossier_autorisation_type.
     * 
     * @param  string $datc type de dossier d'autorisation
     * @return string       numéro de dossier ou false.
     */
    function createNumeroDossier($datc) {
        
        // Créer le code du dossier_autorisation_type associé au code du
        // dossier_autorisation_type_detaille passé en paramètre.
        if ( isset($datc) && is_string($datc) ){
                
            // Récupère l'identifiant suivant dans la séquence correspondant au 
            // code passé en paramètre
            $annee = date('y', strtotime($this->valF["depot_initial"]));
            try {
                $nextID = $this->db->nextId(
                    DB_PREFIXE.'dossier_'.strtolower($datc).'_'.$annee,
                    false);

                if (PEAR::isError($nextID)) {
                    throw new Exception(
                        _("La sequence n'a pas ete mise a jour.")
                    ); 
                }
                $this->addToLog("createNumeroDossier(): db->nextId(
                    \"".DB_PREFIXE."dossier_".strtolower($datc).'_'.$annee."\");",
                    VERBOSE_MODE);
            } catch (Exception $e) {
                // Création de la sequence si elle n'existe pas
                $res = $this->db->createSequence(
                    DB_PREFIXE.'dossier_'.strtolower($datc).'_'.$annee);
                // Affichage du debug
                $this->f->addToLog(
                    "createNumeroDossier(): db->createSequence(".DB_PREFIXE.
                    "\"dossier_".strtolower($datc).'_'.$annee."_seq\"
                    );", VERBOSE_MODE);

                // Si une erreur est levé pour la création.
                if (PEAR::isError($res)) {
                     
                    // Appel de la methode de recuperation des erreurs 
                    $this->erreur_db(
                        $res->getDebugInfo(),
                        $res->getMessage(),
                        'dossier_autorisation'
                    );
                    return false;
                }

                // Mise à jour de la sequence
                // Récupération du code département
                $dep = $this->f->getParameter("departement");
                // Récupération du code commune
                $com = $this->f->getParameter("commune");
                // Vérification de la bonne configuration des paramètres
                if($dep == "" or $com == "") {
                    $this->correct = false;
                    $this->addToMessage(
                        _("Erreur de parametrage. Contactez votre administrateur."));
                }
                // Récupération du dernier DA du typeDA passé en paramètre de
                // l'année de dépôt
                $sql_max_DA = "SELECT dossier_autorisation
                    FROM ".DB_PREFIXE."dossier_autorisation
                    WHERE dossier_autorisation 
                        LIKE '".$datc.$dep.$com.$annee."%'
                    ORDER BY dossier_autorisation DESC";
                $last_DA = $this->db->getone($sql_max_DA);
                $this->f->addToLog(
                    "createNumeroDossier(): db->getone(\"".$sql_max_DA."\"
                    );", VERBOSE_MODE);
                // Si une erreur est levé pour la création.
                if (database::isError($last_DA)) {
                    
                    // Appel de la methode de recuperation des erreurs
                    $this->erreur_db(
                        $nb_DA->getDebugInfo(),
                        $nb_DA->getMessage(),
                        'dossier_autorisation'
                    );
                    return false;
                }
                // Si au moins un dossier on récupère son id
                if($last_DA != "") {
                    $id = intval(substr($last_DA, -5));
                
                    // Mise à jour de la sequence avec l'id recalculé
                    $sql_maj_seq = "SELECT setval('".DB_PREFIXE."dossier_".
                        strtolower($datc)."_".$annee."_seq',".$id.")";
                    $res_seq = $this->db->query($sql_maj_seq);
                    $this->f->addToLog(
                        "createNumeroDossier(): db->query(\"".$sql_maj_seq."\"
                        );", VERBOSE_MODE);
                    // Gestion d'erreurs
                    if (database::isError($res_seq)) {
                    
                        // Appel de la methode de recuperation des erreurs
                        $this->erreur_db(
                            $res_seq->getDebugInfo(),
                            $res_seq->getMessage(),
                            'dossier_autorisation'
                        );
                        return false;
                    }
                }

                // Création du numéro de dossier
                $nextID = $this->db->nextId(
                        DB_PREFIXE.'dossier_'.strtolower($datc).'_'.$annee,
                        false);
                $this->f->addToLog(
                        "createNumeroDossier(): db->nextId(\"".
                            DB_PREFIXE.'dossier_'.strtolower($datc).'_'.$annee."\"
                        );", VERBOSE_MODE);
                // Gestion des erreurs
                if (PEAR::isError($nextID)) {
                    // Appel de la methode de recuperation des erreurs
                    $this->erreur_db(
                        $res_seq->getDebugInfo(),
                        $res_seq->getMessage(),
                        'dossier_autorisation'
                    );
                    return false;
                }
            }            

            $numero_dossier = str_pad($nextID, 5, "0", STR_PAD_LEFT);
        }

        return $numero_dossier;
    }

    /**
     * Méthode permettant de récupérer les id des demandeur liés à la demande ou 
     * liés au dossier d'autorisation
     **/
    function listeDemandeur($from, $id) {
        // Récupération des demandeurs de la base
        $sql = "SELECT demandeur.demandeur,
                        demandeur.type_demandeur,
                        lien_".$from."_demandeur.petitionnaire_principal
            FROM ".DB_PREFIXE."lien_".$from."_demandeur
            INNER JOIN ".DB_PREFIXE."demandeur 
            ON demandeur.demandeur=lien_".$from."_demandeur.demandeur 
            WHERE ".$from." = '".$id."'";
        $res = $this->f->db->query($sql);
        $this->f->addToLog("listeDemandeur() : db->query(\"".$sql."\")", VERBOSE_MODE);
        if ( database::isError($res)){
            die();
        }
        // Stoquage du résultat dans un tableau
        while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)){
            if ($row['petitionnaire_principal'] == 't' AND
                $row['type_demandeur']=="petitionnaire") {
                $this->valIdDemandeur['petitionnaire_principal']=$row['demandeur'];
            } elseif ($row['petitionnaire_principal'] == 'f' AND
                $row['type_demandeur']=="petitionnaire"){
                $this->valIdDemandeur['petitionnaire'][]=$row['demandeur'];
            } elseif ($row['type_demandeur']=="delegataire"){
                $this->valIdDemandeur['delegataire']=$row['demandeur'];
            }
        }
    }

    /**
     * Ajout de la liste des demandeurs
     */
    function formSpecificContent($maj) {
        if(!$this->correct AND $maj != 0) {
            $this->listeDemandeur("dossier_autorisation", $this->val[array_search('dossier_autorisation', $this->champs)]);
        }
        if($maj < 2 AND !$this->correct) {
            $linkable = true;
        } else {
            $linkable = false;
        }

        // Conteneur de la listes des demandeurs
        echo "<div id=\"liste_demandeur\" class=\"demande_hidden_bloc col_12\">";
        echo "<fieldset class=\"cadre ui-corner-all ui-widget-content\">";
        echo "  <legend class=\"ui-corner-all ui-widget-content ui-state-active\">"
                ._("Petitionnaire")."</legend>";
        // Si des demandeurs sont liés à la demande
        require_once "../obj/petitionnaire.class.php";
        require_once "../obj/delegataire.class.php";

            // Affichage du bloc pétitionnaire principal / délégataire
            // L'ID DU DIV SUIVANT EST NECESSAIRE AU BON FONCTIONNEMENT DU JS
            echo "<div id=\"petitionnaire_principal_delegataire\">";
            // Affichage de la synthèse
            if (isset ($this->valIdDemandeur["petitionnaire_principal"]) AND
                !empty($this->valIdDemandeur["petitionnaire_principal"])) {
                $demandeur = new petitionnaire(
                                    $this->valIdDemandeur["petitionnaire_principal"],
                                    $this->f->db,false);
                $demandeur -> afficherSynthese("petitionnaire_principal", $linkable);
                $demandeur -> __destruct();
            }
            // Si en édition de formulaire
            if($maj < 2) {
                // Bouton d'ajout du pétitionnaire principal
                // L'ID DE L'INPUT SUIVANT EST NECESSAIRE AU BON FONCTIONNEMENT DU JS
                echo "<span id=\"add_petitionnaire_principal\"
                    class=\"om-form-button add-16\">".
                    _("Saisir le petitionnaire principal").
                "</span>";
            }
            // Bouton d'ajout du delegataire
            // L'ID DU DIV ET DE L'INPUT SUIVANT EST NECESSAIRE AU BON FONCTIONNEMENT DU JS
            echo "<div id=\"delegataire\">";
            if ($maj < 2 OR ($maj == 3 AND !empty($this->valIdDemandeur["delegataire"]))) {
                echo " <span class=\"om-icon om-icon-16 om-icon-fix arrow-right-16\">
                        <!-- -->
                    </span> ";
            }
            // Affichage de la synthèse
            if (isset ($this->valIdDemandeur["delegataire"]) AND
                !empty($this->valIdDemandeur["delegataire"])) {
                $demandeur = new delegataire($this->valIdDemandeur["delegataire"],
                                           $this->f->db,false);
                $demandeur -> afficherSynthese("delegataire", $linkable);
                $demandeur -> __destruct();
            }
            if($maj < 2) {
                echo "<span id=\"add_delegataire\"
                        class=\"om-form-button add-16\">".
                        _("Saisir le delegataire").
                    "</span>";
            }
            echo "</div>";
            
            echo "</div>";
            // Bloc des pétitionnaires secondaires
            // L'ID DU DIV SUIVANT EST NECESSAIRE AU BON FONCTIONNEMENT DU JS
            echo "<div id=\"listePetitionnaires\">";

             // Affichage de la synthèse
            if (isset ($this->valIdDemandeur["petitionnaire"]) AND
                !empty($this->valIdDemandeur["petitionnaire"])) {
                
                foreach ($this->valIdDemandeur["petitionnaire"] as $petitionnaire) {
                    $demandeur = new petitionnaire($petitionnaire,
                                           $this->f->db,false);
                    $demandeur -> afficherSynthese("petitionnaire", $linkable);
                    $demandeur -> __destruct();
                }
                
            }
            if ($maj < 2) {
                // L'ID DE L'INPUT SUIVANT EST NECESSAIRE AU BON FONCTIONNEMENT DU JS
                echo "<span id=\"add_petitionnaire\"
                        class=\"om-form-button add-16\">".
                        _("Ajouter un petitionnaire")
                    ."</span>";
            }
            echo "</div>";
        echo "</fieldset>";
        echo "</div>";
    }


    /**
     * Méthode permettant de recalculer à tout moment les données en cours de
     * validité d'un dossier d'autorisation
     */
    function majDossierAutorisation() {

        /*
         * Mise à jour des données (terrain, ref. cadastrales, demandeurs, lots)
         */
        // Initialisation des requêtes
        $sql_terrain = "SELECT dossier.terrain_references_cadastrales,
                            dossier.terrain_adresse_voie_numero,
                            dossier.terrain_adresse_voie,
                            dossier.terrain_adresse_lieu_dit,
                            dossier.terrain_adresse_localite,
                            dossier.terrain_adresse_code_postal,
                            dossier.terrain_adresse_bp,
                            dossier.terrain_adresse_cedex,
                            dossier.terrain_superficie
                        FROM ".DB_PREFIXE."dossier";

        $sql_lots = "SELECT lot.lot 
                    FROM ".DB_PREFIXE."lot
                    JOIN ".DB_PREFIXE."dossier ON dossier.dossier = lot.dossier";

        $sql_demandeurs = "SELECT lien_dossier_demandeur.demandeur, lien_dossier_demandeur.petitionnaire_principal,
                            lien_dossier_demandeur.lien_dossier_demandeur, lien_dossier_demandeur.dossier
                            FROM ".DB_PREFIXE."lien_dossier_demandeur
                            LEFT JOIN ".DB_PREFIXE."dossier ON
                            lien_dossier_demandeur.dossier = dossier.dossier";
        $sql_etat = "SELECT avis_decision.typeavis
                    FROM ".DB_PREFIXE."dossier";
        // Récupération du nombre de dossiers d'instruction liés au dossier d'autorisation
        $sql_count_di = "SELECT count(*) FROM ".DB_PREFIXE."dossier as di 
                            WHERE di.dossier_autorisation = '".$this->getVal("dossier_autorisation")."'";

        $count_di = $this->db->getOne($sql_count_di);
        $this->addToLog("majDossierAutorisation(): db->getone(\"".$sql_count_di."\")", VERBOSE_MODE);
        if(database::isError($count_di)) {
            // Appel de la methode de recuperation des erreurs
            $this->erreur_db($count_di->getDebugInfo(), $count_di->getMessage(), '');
            return false;
        }
        // Si pas de dossier : erreur
        if ($count_di == 0) {
            return false;
        } elseif ($count_di == 1) { // Cas P0 (en cours ou non) ou de plusieurs DI en cours
            $sql_where = " WHERE dossier.dossier_autorisation = '".$this->getVal("dossier_autorisation")."'";
        } else { // Cas ou un dossier d'instruction est soumis à arrété
            $sql_where = " WHERE dossier.dossier = (
                                        SELECT dossier.dossier
                                        FROM ".DB_PREFIXE."dossier
                                        JOIN ".DB_PREFIXE."avis_decision 
                                            ON dossier.avis_decision = avis_decision.avis_decision
                                        WHERE  dossier.dossier_autorisation = '".$this->getVal("dossier_autorisation")."'
                                            AND date_decision IS NOT NULL
                                            AND avis_decision.typeavis='F'
                                        ORDER BY version DESC
                                        LIMIT 1
                                    )";
        }

        //terrain
        $res_terrain = $this->db->query($sql_terrain.$sql_where);
        $this->addToLog("majDossierAutorisation(): db->query(\"".$sql_terrain.$sql_where."\")", VERBOSE_MODE);
        if(database::isError($res_terrain)) {
            // Appel de la methode de recuperation des erreurs
            $this->erreur_db($res_terrain->getDebugInfo(), $res_terrain->getMessage(), '');
            return false;
        }
        $row_terrain = $res_terrain->fetchRow(DB_FETCHMODE_ASSOC);
        // Tous les champs vides sont mis à NULL pour éviter les erreurs de base lors de l'update
        foreach ($row_terrain as $key => $champ) {
            if ($champ == "") {
                $row_terrain[$key] = NULL;
            }
        }
        $res_update_terrain = $this->db->autoExecute(DB_PREFIXE."dossier_autorisation",
                                                     $row_terrain,
                                                     DB_AUTOQUERY_UPDATE,
                                                     "dossier_autorisation = '".$this->getVal("dossier_autorisation")."'");
        if(database::isError($res_update_terrain)) {
            // Appel de la methode de recuperation des erreurs
            $this->erreur_db($res_update_terrain->getDebugInfo(), $res_update_terrain->getMessage(), '');
            return false;
        }

        // Lots / demandeur
        // Suppression des anciens liens entre les lots et le DA
        $valLot['dossier_autorisation'] = NULL;
        $res_update_lots = $this->db->autoExecute(DB_PREFIXE."lot",
                                                  $valLot,
                                                  DB_AUTOQUERY_UPDATE,
                                                  "dossier_autorisation='".$this->getVal("dossier_autorisation")."'");
        $sql = "SELECT count(*) FROM ".DB_PREFIXE."lot WHERE dossier_autorisation='".$this->getVal("dossier_autorisation")."'";
        if(database::isError($res_update_lots)) {
            // Appel de la methode de recuperation des erreurs
            $this->erreur_db($res_update_terrain->getDebugInfo(), $res_update_terrain->getMessage(), '');
            return false;
        }
        // Suppression des anciens liens dossier_autorisation/demandeurs
        $sql_delete_liens_da_demandeur = "DELETE FROM ".DB_PREFIXE."lien_dossier_autorisation_demandeur
                                            WHERE dossier_autorisation='".$this->getVal("dossier_autorisation")."'";
        $res_delete_liens_da_demandeur = $this->db->query($sql_delete_liens_da_demandeur);
        $this->addToLog("majDossierAutorisation(): db->query(\"".$sql_delete_liens_da_demandeur."\")", VERBOSE_MODE);
        if(database::isError($res_delete_liens_da_demandeur)) {
            // Appel de la methode de recuperation des erreurs
            $this->erreur_db($res_delete_liens_da_demandeur->getDebugInfo(), $res_delete_liens_da_demandeur->getMessage(), '');
            return false;
        }
        // Si il ya des lots liés on les remonte au DA et on omet les demandeurs
        // car ils sont liés aux  lots
        $res_lots = $this->db->query($sql_lots.$sql_where);
        $this->addToLog("majDossierAutorisation(): db->query(\"".$sql_lots.$sql_where."\")", VERBOSE_MODE);
        if(database::isError($res_lots)) {
            // Appel de la methode de recuperation des erreurs
            $this->erreur_db($res_lots->getDebugInfo(), $res_lots->getMessage(), '');
            return false;
        }

        // XXX Si il existe des lots (auxquels les demandeurs sont lié) faut-il recupérer la liste des demandeurs liés au DI ?
        //if ($res_lots->numRows() > 0) {
            // Définition du lien entre lot et dossier_autorisation pour chaque lot
            $valLotUpdate['dossier_autorisation'] = $this->getVal("dossier_autorisation");
            // On lie chaque lot en définissant l'id du dossier d'autorisation
            while ($rowlot = $res_lots->fetchRow(DB_FETCHMODE_ASSOC)) {
                $res_lots_update = $this->db->autoExecute(DB_PREFIXE."lot",
                                                           $valLotUpdate,
                                                           DB_AUTOQUERY_UPDATE,
                                                           "lot=".$rowlot['lot']);
                if(database::isError($res_lots_update)) {
                    // Appel de la methode de recuperation des erreurs
                    $this->erreur_db($res_lots_update->getDebugInfo(), $res_lots_update->getMessage(), '');
                    return false;
                }
            }
        //} else { // Si pas de lot liaison avec les demandeurs
            // Récupération de la liste des demandeurs
            $res_demandeurs = $this->db->query($sql_demandeurs.$sql_where);
            $this->addToLog("majDossierAutorisation(): db->query(\"".$sql_demandeurs.$sql_where."\")", VERBOSE_MODE);
            if(database::isError($res_demandeurs)) {
                // Appel de la methode de recuperation des erreurs
                $this->erreur_db($res_demandeurs->getDebugInfo(), $res_demandeurs->getMessage(), '');
                return false;
            }
            // Définition de l'id du DA
            $valDemandeurUpdate["lien_dossier_autorisation_demandeur"] = NULL;
            $valDemandeurUpdate['dossier_autorisation'] = $this->getVal("dossier_autorisation");
            // Pour chaque demandeur on créer un lien avec le DA
            while ($rowDemandeur = $res_demandeurs->fetchRow(DB_FETCHMODE_ASSOC)) {
                // Ajout de l'id du demandeur et du flag petitionnaire_principal
                // aux données à insérer
                $valDemandeurUpdate["demandeur"] = $rowDemandeur["demandeur"];
                $valDemandeurUpdate["petitionnaire_principal"] = $rowDemandeur["petitionnaire_principal"];
                // Instanciation d'un lien dossier_autorisation/demandeur en ajout
                require_once "../obj/lien_dossier_autorisation_demandeur.class.php";
                $ldad = new lien_dossier_autorisation_demandeur("]", $this->db, DEBUG);
                // Ajout d'un enregistrement avec les données des liens
                $ldad->ajouter($valDemandeurUpdate, $this->db, DEBUG);
            }
        //}


        /**
         * Mise à jour des dates
         */
        // Requêtes permettant de les recupérer
        $sql_date_depot_decision_validite = "SELECT MIN(dossier.date_depot) as date_depot, MIN(dossier.date_decision) as date_decision, MAX(dossier.date_validite) as date_validite FROM ".DB_PREFIXE."dossier 
                            WHERE dossier.dossier_autorisation='".$this->getVal("dossier_autorisation")."'";
     
        $sql_date_doc_daact = "SELECT MAX(dossier.date_chantier) as date_chantier, MAX(dossier.date_achevement) as date_achevement FROM ".DB_PREFIXE."dossier 
                            LEFT OUTER JOIN ".DB_PREFIXE."avis_decision ON
                                dossier.avis_decision = avis_decision.avis_decision
                            WHERE dossier.dossier_autorisation = '".$this->getVal("dossier_autorisation")."'
                                AND date_decision IS NOT NULL AND avis_decision.typeavis='F'";
        // Récupération des infos avec la 1ere requête
        $res_date_depot_decision_validite = $this->db->query($sql_date_depot_decision_validite);
        $this->addToLog("majDossierAutorisation(): db->query(\"".$sql_date_depot_decision_validite."\")", VERBOSE_MODE);
        if(database::isError($res_date_depot_decision_validite)) {
            // Appel de la methode de recuperation des erreurs
            $this->erreur_db($res_date_depot_decision_validite->getDebugInfo(), $res_date_depot_decision_validite->getMessage(), '');
            return false;
        }
        $row_date_depot_decision_validite = $res_date_depot_decision_validite->fetchRow(DB_FETCHMODE_ASSOC);
        // Récupération des infos avec la 2nd requête
        $res_date_doc_daact = $this->db->query($sql_date_doc_daact);
        $this->addToLog("majDossierAutorisation(): db->query(\"".$sql_date_doc_daact."\")", VERBOSE_MODE);
        if(database::isError($res_date_doc_daact)) {
            // Appel de la methode de recuperation des erreurs
            $this->erreur_db($res_date_doc_daact->getDebugInfo(), $res_date_doc_daact->getMessage(), '');
            return false;
        }
        $row_date_doc_daact = $res_date_doc_daact->fetchRow(DB_FETCHMODE_ASSOC);
        // Fusion des 2 résultats
        $row_date = array_merge($row_date_depot_decision_validite, $row_date_doc_daact);
        // Si pas de date on remplace "" par NULL pour éviter les erreurs de base de données
        foreach($row_date as $key => $date) {
            if($date == "") {
                $row_date[$key] = NULL;
            }
        }
        // Mise à jour du DA avec ces nouvelles dates
        $res_update_date = $this->db->autoExecute(DB_PREFIXE."dossier_autorisation",
                                                     $row_date,
                                                     DB_AUTOQUERY_UPDATE,
                                                     "dossier_autorisation = '".$this->getVal("dossier_autorisation")."'");
        if(database::isError($res_update_date)) {
            // Appel de la methode de recuperation des erreurs
            $this->erreur_db($res_update_date->getDebugInfo(), $res_update_date->getMessage(), '');
            return false;
        }

        /**
         * Mise à jour de l'état
         */
        $sql_etat = "SELECT avis_decision.typeavis, avis_decision.avis_decision
                        FROM ".DB_PREFIXE."dossier
                        LEFT JOIN ".DB_PREFIXE."avis_decision ON
                            dossier.avis_decision = avis_decision.avis_decision";

        // Récupération de le décision du dernier dossier en cours ou non
        $sql_encours = $sql_etat." WHERE dossier.dossier_autorisation = '".$this->getVal("dossier_autorisation")."' ORDER BY dossier.version DESC";

        // Récupération de la décision du dernier dossier accepté
        $sql_cloture = $sql_etat." WHERE dossier.dossier_autorisation = '".$this->getVal("dossier_autorisation")."'
                        AND date_decision IS NOT NULL AND avis_decision.typeavis='F'
                    ORDER BY dossier.version DESC";

        $res_encours = $this->db->query($sql_encours);
        $this->addToLog("majDossierAutorisation(): db->query(\"".$sql_encours."\")", VERBOSE_MODE);
        if(database::isError($res_encours)) {
            // Appel de la methode de recuperation des erreurs
            $this->erreur_db($res_encours->getDebugInfo(), $res_encours->getMessage(), '');
            return false;
        }

        $row_encours = $res_encours->fetchRow(DB_FETCHMODE_ASSOC);
        $etatDA = array();

        // Cas initial : on défini les trois valeurs par défaut
        // (elles seront écrasées si $res_encours->numRows() > 1)

        // Correspondance entre typeavis et etat_dossier_autorisation
        switch ($row_encours['typeavis']) {
            case 'F':
                // typeavis F => Accordé
                $etatDA['etat_dernier_dossier_instruction_accepte'] = 2;
                $etatDA['etat_dossier_autorisation'] = 2;
                break;
            case 'D':
                // typeavis D => Refusé
                $etatDA['etat_dernier_dossier_instruction_accepte'] = 4;
                $etatDA['etat_dossier_autorisation'] = 4;
                break;
            case 'A':
                // typeavis A => Abandonné
                $etatDA['etat_dernier_dossier_instruction_accepte'] = 3;
                $etatDA['etat_dossier_autorisation'] = 3;
                break;
            default:
                // typeavis '' => En cours
                $etatDA['etat_dernier_dossier_instruction_accepte'] = NULL;
                $etatDA['etat_dossier_autorisation'] = 1;
                break;
        }
        $etatDA['avis_decision'] = $row_encours['avis_decision'];

        // Si plus d'un dossier d'instruction 
        if($res_encours->numRows() > 1) {
            $res_cloture = $this->db->query($sql_cloture);
            $this->addToLog("majDossierAutorisation(): db->query(\"".$sql_cloture."\")", VERBOSE_MODE);
            if(database::isError($res_cloture)) {
                // Appel de la methode de recuperation des erreurs
                $this->erreur_db($res_cloture->getDebugInfo(), $res_cloture->getMessage(), '');
                return false;
            }

            $row_cloture = $res_cloture->fetchRow(DB_FETCHMODE_ASSOC);
            // Correspondance entre typeavis et etat_dossier_autorisation
            switch ($row_cloture['typeavis']) {
                case 'F':
                    // typeavis F => Accordé
                    $etatDA['etat_dernier_dossier_instruction_accepte'] = 2;
                    break;
                case 'D':
                    // typeavis D => Refusé
                    $etatDA['etat_dernier_dossier_instruction_accepte'] = 4;
                    break;
                case 'A':
                    // typeavis A => Abandonné
                    $etatDA['etat_dernier_dossier_instruction_accepte'] = 3;
                    break;
                default:
                    // typeavis '' => En cours
                    $etatDA['etat_dernier_dossier_instruction_accepte'] = NULL;
                    break;
            }
            $etatDA['avis_decision'] = $row_cloture['avis_decision'];
        }
        foreach($etatDA as $key=>$val) {
            if($val=="") {
                $etatDA[$key] = NULL;
            }
        }

        // Mise à jour du DA avec ces nouvelles dates
        $res_update_etat = $this->db->autoExecute(DB_PREFIXE."dossier_autorisation",
                                                     $etatDA,
                                                     DB_AUTOQUERY_UPDATE,
                                                     "dossier_autorisation = '".$this->getVal("dossier_autorisation")."'");
        if(database::isError($res_update_date)) {
            // Appel de la methode de recuperation des erreurs
            $this->erreur_db($res_update_date->getDebugInfo(), $res_update_date->getMessage(), '');
            return false;
        }

        // Si le champ des références cadastrales n'est pas vide
        if ($this->getVal('terrain_references_cadastrales') 
            != $row_terrain['terrain_references_cadastrales']) {

            // On supprime toutes les lignes de la table 
            // dossier_autorisation_parcelle qui font référence au 
            // dossier d'autorisation en cours de suppression
            $this->supprimer_dossier_autorisation_parcelle($this->getVal('dossier_autorisation'));

            // Ajout des parcelles dans la table dossier_autorisation_parcelle
            $this->ajouter_dossier_autorisation_parcelle($this->getVal('dossier_autorisation'), 
                $row_terrain['terrain_references_cadastrales']);

        }
    }

    /**
     * Ajoute les parcelles du dossier d'autorisation passé en paramètre
     * @param  string $dossier_autorisation           Identifiant du dossier
     * @param  string $terrain_references_cadastrales Références cadastrales du 
     *                                                dossier
     */
    function ajouter_dossier_autorisation_parcelle($dossier_autorisation, $terrain_references_cadastrales) {

        // Parse les parcelles
        $list_parcelles = $this->f->parseParcelles($terrain_references_cadastrales);

        // Fichier requis
        require_once "../obj/dossier_autorisation_parcelle.class.php";

        // A chaque parcelle une nouvelle ligne est créée dans la table
        // dossier_parcelle
        foreach ($list_parcelles as $parcelle) {

            // Instance de la classe dossier_parcelle
            $dossier_autorisation_parcelle = new dossier_autorisation_parcelle("]", $this->db, DEBUG);

            // Valeurs à sauvegarder
            $value = array(
                'dossier_autorisation_parcelle' => '',
                'dossier_autorisation' => $dossier_autorisation,
                'parcelle' => '',
                'libelle' => $parcelle['quartier']
                                .$parcelle['section']
                                .$parcelle['parcelle']
            );

            // Ajout de la ligne
            $dossier_autorisation_parcelle->ajouter($value, $this->db, DEBUG);
        }

    }

    /**
     * Supprime les parcelles du dossier d'autorisation passé en paramètre
     * @param  string $dossier_autorisation Identifiant du dossier
     */
    function supprimer_dossier_autorisation_parcelle($dossier_autorisation) {

        // Suppression des parcelles du dossier d'autorisation
        $sql = "DELETE FROM ".DB_PREFIXE."dossier_autorisation_parcelle
                WHERE dossier_autorisation='".$dossier_autorisation."'";
        $res = $this->db->query($sql);
        $this->addToLog("supprimer_dossier_autorisation_parcelle() db->query(\"".$sql."\");", VERBOSE_MODE);
        database::isError($res);

    }

    /**
     * Permet d’effectuer des actions après l’insertion des données dans la base
     */
    function triggerajouterapres($id, &$db, $val, $DEBUG) {

        // Si le champ des références cadastrales n'est pas vide
        if ($this->valF['terrain_references_cadastrales'] != '') {

            // Ajout des parcelles dans la table dossier_autorisation_parcelle
            $this->ajouter_dossier_autorisation_parcelle($this->valF['dossier_autorisation'], 
                $this->valF['terrain_references_cadastrales']);

        }

    }

}// fin classe
?>