<?php
/**
 * Ce fichier permet de déclarer la classe MaintenanceManager, qui effectue les
 * traitements pour la ressource 'maintenance'.
 *
 * @package openfoncier
 * @version SVN : $Id$
 */

// Inclusion de la classe de base MetierManager
require_once("./metier/metiermanager.php");

/**
 * Cette classe hérite de la classe MetierManager. Elle permet d'effectuer des
 * traitements pour la ressource 'maintenance' qui ont vocation à être
 * déclenché de manière automatique ou par une application externe. Par
 * exemple, un cron permet chaque soir d'exécuter la synchronisation des
 * utilisateurs de l'application avec l'annuaire LDAP.
 */
class MaintenanceManager extends MetierManager {

    /**
     * @var mixed Ce tableau permet d'associer un module a une méthode,
     * le module (key) est celui reçu dans la requête REST, la méthode (value)
     * est la méthode de cette classe qui va exécuter le traitement
     */
    var $fptrs = array(
        'user' => 'synchronizeUsers',
        'consultation' => 'updateConsultationsStates',
        'instruction' => 'updateDossierTacite',
        'import' => 'importDigitalizedDocuments',
        'purge' => 'purgeDigitalizedDocuments',
        'update_dossier_autorisation' => 'updateDAState',
        'maj_da_reprise' => 'majDAReprise',
        'maj_dt_reprise' => 'majDTReprise',
        'contrainte' => 'synchronisationContraintes',
    );

    /**
     * Cette méthode permet de gérer l'appel aux différentes méthodes
     * correspondantes au module appelé.
     *
     * @param string $module Le module à exécuter reçu dans la requête
     * @param mixed $data Les données reçues dans la requête
     * @return string Le résultat du traitement
     */
    public function performMaintenance($module, $data) {

        // Si le module n'existe pas dans la liste des modules disponibles
        // alors on ajoute un message d'informations et on retourne un
        // un résultat d'erreur
        if (!in_array($module, array_keys($this->fptrs))) {
            $this->setMessage("Le module demandé n'existe pas");
            return $this->BAD_DATA;
        }

        // Si le module existe dans la liste des modules disponibles
        // alors on appelle la méthode en question et on retourne son résultat
        return call_user_func(array($this, $this->fptrs[$module]), $data);

    }

    /**
     * Cette méthode permet d'effectuer la synchronisation des utilisateurs
     * de l'application avec l'annuaire LDAP paramétré dans l'application.
     * 
     * @param mixed $data Les données reçues dans la requête
     * @return string Le résultat du traitement
     *
     * @todo XXX Faire une getsion des erreurs dans om_application pour
     * permettre d'avoir un retour sur le nombre d'utilisateurs synchronisés
     */    
    public function synchronizeUsers($data) {

        // Initialisation de la synchronisation des utilisateurs LDAP
        $results = $this->f->initSynchronization();

        // Si l'initialisation ne se déroule pas correctement alors on retourne
        // un résultat d'erreur
        if (is_null($results) || $results == false) {
            $this->setMessage("Erreur interne");
            return $this->KO;
        }

        // Application du traitement de synchronisation
        $ret = $this->f->synchronizeUsers($results);

        // Si l'a synchronisation ne se déroule pas correctement alors on
        // retourne un résultat d'erreur
        if ($ret == false) {
            $this->setMessage("Erreur interne");
            return $this->KO;
        }

        // Si l'a synchronisation ne se déroule correctement alors on
        // retourne un résultat OK
        $this->setMessage("Synchronisation terminée.");
        return $this->OK;

    }

    /**
     * Cette méthode permet d'effectuer le traitement de gestion des avis
     * tacites sur les consultations qui ont atteint leur date limite de
     * retour.
     * 
     * @param mixed $data Les données reçues dans la requête
     * @return string Le résultat du traitement
     *
     * @todo Vérifier si il est possible de déplacer la méthode dans
     * l'application
     */
    public function updateConsultationsStates($data) {

        // Nom de la table
        $table_name = 'consultation';

        // Récupération de la référence vers un avis_consultation correspondant
        // au libellé 'Tacite'
        $sql = "SELECT avis_consultation FROM ".DB_PREFIXE."avis_consultation ";
        $sql .= " WHERE libelle = 'Tacite' ";
        $sql .= " AND ((avis_consultation.om_validite_debut IS NULL ";
        $sql .= " AND (avis_consultation.om_validite_fin IS NULL ";
        $sql .= " OR avis_consultation.om_validite_fin > CURRENT_DATE)) ";
        $sql .= " OR (avis_consultation.om_validite_debut <= CURRENT_DATE ";
        $sql .= " AND (avis_consultation.om_validite_fin IS NULL ";
        $sql .= " OR avis_consultation.om_validite_fin > CURRENT_DATE))) ";
        $res = $this->db->query($sql);
        // Logger
        $this->addToLog("updateConsultationsStates(): db->query(\"".$sql."\"", VERBOSE_MODE);
        // Si une erreur de base de données se produit sur cette requête
        // alors on retourne un résultat d'erreur
        if ($this->f->isDatabaseError($res, true)) {
            $this->setMessage("Erreur de base de données.");
            return $this->KO;
        }

        // Récupération de la référence vers un avis_consultation correspondant
        // au libellé 'Tacite'
        $tacite = NULL;
        while ($row =& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
            $tacite = $row["avis_consultation"];
        }
        $res->free();

        // Si la décision n'existe pas dans la base de données alors on ajoute
        // un message d'informations et on retourne un résultat d'erreur
        if (is_null($tacite)) {
            $this->setMessage("L'avis n'existe pas.");
            return $this->KO;
        }

        // Récupération de la liste des consultations correspondantes aux
        // critères du traitement
        $sql = "SELECT consultation, date_limite FROM ".DB_PREFIXE."$table_name ";
        $sql .= " WHERE date_limite < CURRENT_DATE" ;
        $sql .= " AND date_retour IS NULL AND avis_consultation IS NULL ";
        $res = $this->db->query($sql);
        // Logger
        $this->addToLog("updateConsultationsStates(): db->query(\"".$sql."\"", VERBOSE_MODE);
        // Si une erreur de base de données se produit sur cette requête
        // alors on retourne un résultat d'erreur
        if ($this->f->isDatabaseError($res, true)) {
            $this->setMessage("Erreur de base de données.");
            return $this->KO;
        }
        
        // Si aucune consultation n'est concernée par le traitement alors on
        // ajoute un message d'informations et on retourne un résultat 'OK'
        if ($res->numrows() == 0) {
            $this->setMessage("Aucune mise a jour.");
            return $this->OK;
        }
        
        $nb_consultations_maj = 0;
        //Pour chaque consultation correspondantes aux critères
        while ($row =& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
            //
            $fields = array(
                'avis_consultation' => $tacite,
                'date_retour' => $row["date_limite"],
                'lu' => false
            );
            //
            $res_update = $this->db->autoExecute(DB_PREFIXE.$table_name,
                                          $fields,
                                          DB_AUTOQUERY_UPDATE,
                                          'consultation = \''.$row["consultation"].'\'');
            // Logger
            $this->addToLog("updateConsultationsStates(): db->autoExecute(\"".DB_PREFIXE.$table_name."\", ".print_r($fields, true).", DB_AUTOQUERY_UPDATE, \"consultation = \"".$row["consultation"]."\"", VERBOSE_MODE);
            // Si une erreur de base de données se produit sur cette requête
            // alors on retourne un résultat d'erreur
            if ($this->f->isDatabaseError($res_update, true)) {
                $this->setMessage("Erreur de base de données.");
                return $this->KO;
            }
            //
            $nb_consultations_maj++;
        }
        // Tout s'est déroulé correctement alors on ajoute un message
        // d'informations et on retourne le résultat 'OK'
        $this->setMessage($nb_consultations_maj." consultations mise(s) à jour.");
        return $this->OK;

    }

    /**
     * Cette méthode permet d'ajouter une instruction sur les dossiers tacites : 
     * - soit les tacites normaux
     * - soit les incomplets ayant un événement tacites
     */
    public function updateDossierTacite() {
        // Liste les dossiers tacites
        // UNION
        // liste des dossiers incomplets tacites
        $sql_dossier_tacite = 
               "SELECT dossier.dossier, dossier.evenement_suivant_tacite
                FROM ".DB_PREFIXE."dossier
                LEFT JOIN ".DB_PREFIXE."instruction ON
                    instruction.dossier=dossier.dossier AND instruction.evenement = dossier.evenement_suivant_tacite
                WHERE dossier.date_limite < now()
                        AND dossier.accord_tacite = 'Oui'
                        AND dossier.evenement_suivant_tacite IS NOT NULL
                        AND dossier.incomplet_notifie = FALSE
                        AND instruction.instruction IS NULL
                        AND dossier.avis_decision IS NULL
                UNION 
                SELECT dossier.dossier, dossier.evenement_suivant_tacite_incompletude as evenement_suivant_tacite
                FROM ".DB_PREFIXE."dossier
                LEFT JOIN ".DB_PREFIXE."instruction ON
                    instruction.dossier=dossier.dossier AND instruction.evenement = dossier.evenement_suivant_tacite
                WHERE dossier.date_limite_incompletude < now()
                        AND dossier.accord_tacite = 'Oui'
                        AND dossier.evenement_suivant_tacite_incompletude IS NOT NULL
                        AND dossier.incomplet_notifie = TRUE
                        AND dossier.incompletude = TRUE
                        AND instruction.instruction IS NULL
                        AND dossier.avis_decision IS NULL";

        $res_dossier_tacite = $this->db->query($sql_dossier_tacite);
        if ($this->f->isDatabaseError($res_dossier_tacite, true)) {
            $this->setMessage("Erreur de base de données.");
            return $this->KO;
        }// Inclusion de la classe de base MetierManager
        $nb_maj = 0;
        while ($row_dossier_tacite =& $res_dossier_tacite->fetchRow(DB_FETCHMODE_ASSOC)) {
            // essai d'ajout des donnees dans la base de donnees
            $this->db->autoCommit(false);
            // Si un evenement est configuré suivant tacite
            $valNewInstr = array();
            require_once("../obj/instruction.class.php");
            $instruction = new instruction("]", $this->db, 0);
            // Création d'un tableau avec la liste des champs de l'instruction
            foreach($instruction->champs as $champ) {
                if($champ != "bible_auto") {
                    $valNewInstr[$champ] = ""; 
                }
            }

            // Définition des valeurs de la nouvelle instruction
            $valNewInstr["evenement"] = $row_dossier_tacite["evenement_suivant_tacite"];
            $valNewInstr["dossier"] = $row_dossier_tacite['dossier'];
            $valNewInstr["date_evenement"] = date("d/m/Y");
            $instruction->valF = array();
            $res_ajout = $instruction->ajouter($valNewInstr, $this->db, $this->DEBUG);
            if ($res_ajout === false) {
                $instruction->undoValidation();
                $this->setMessage("Erreur de base de données.");
                return $this->KO;
            } else {
                $this->db->commit();
                $nb_maj++;
            }

        }

        // Si aucune instruction n'est concernée par le traitement alors on
        // ajoute un message d'informations et on retourne un résultat 'OK'
        if ($nb_maj == 0) {
            $this->setMessage("Aucune mise a jour.");
            return $this->OK;
        }

        // Tout s'est déroulé correctement alors on ajoute un message
        // d'informations et on retourne le résultat 'OK'
        $this->setMessage($nb_maj." dossier(s) mis à jour.");
        return $this->OK;
    }

    /**
     * Cette méthode permet de faire l'importation des documents scannés
     * @param  string $data données envoyé en paramètre
     */
    public function importDigitalizedDocuments($data) {

        //Instance classe DigitalizedDocument
        require_once("../obj/digitalizedDocument.class.php");
        $digitalizedDocument = new DigitalizedDocument($this->f);

        //Chemin des dossiers source et destination
        $path = $data;

        //Si deux données sont présentes dans $data
        if (!empty($path)) {

            //Dossier source
            $pathSrc = isset($path["Todo"])?$path["Todo"]:"";
            //Aucun chemin n'est fourni pour le dossier source, on utilise la
            //configuration
            if($pathSrc===""){
                //Si le répertoire de numérisation n'est pas configuré
                if (!isset($this->f->config["path_scan"])) {
                    //Message erreur
                    $this->setMessage(_("Le repertoire de numerisation n'est pas configure"));
                    return $this->KO;
                }
    
                $pathSrc = $this->f->config['path_scan'].'Todo/';
            }
            //Si le dossier n'existe pas, on retourne une erreur
            elseif (!is_dir($pathSrc)) {
                //Message erreur
                $this->setMessage(_("Le repertoire de numerisation fourni n'existe pas"));
                return $this->KO;
            }
            
            //Dossier de destination
            $pathDes = isset($path["Done"])?$path["Done"]:"";
            //Aucun chemin n'est fourni pour le dossier de destination, on utilise la
            //configuration
            if($pathDes===""){
                //Si le répertoire de numérisation n'est pas configuré
                if (!isset($this->f->config["path_scan"])) {
                    //Message erreur
                    $this->setMessage(_("Le repertoire de numerisation n'est pas configure"));
                    return $this->KO;
                }
    
                $pathDes = $this->f->config['path_scan'].'Done/';
            }
            //Si le dossier n'existe pas, on retourne une erreur
            elseif (!is_dir($pathDes)) {
                //Message erreur
                $this->setMessage(_("Le repertoire de numerisation fourni n'existe pas"));
                return $this->KO;
            }
        } else {

            //Si le répertoire de numérisation n'est pas configuré
            if (!isset($this->f->config["path_scan"])) {
                //Message erreur
                $this->setMessage(_("Le repertoire de numerisation n'est pas configure"));
                return $this->KO;
            }

            $pathSrc = $this->f->config['path_scan'].'Todo/';
            $pathDes = $this->f->config['path_scan'].'Done/';
        }        

        //
        $repo = scandir($pathSrc);
        $importDone = FALSE;
        $importErrorFilename = array();

        //Si le dossier est ouvert
        if ($repo) {
            //
            foreach ($repo as $key => $folder) {
                
                //Vérifie qu'il s'agit de dossier correct
                if ($folder != '.' && $folder != '..' && $folder != '.svn') {
                    
                    //Importation des documents
                    $import = $digitalizedDocument->run_import($pathSrc.'/'.$folder, $pathDes.'/'.$folder, $this->DEBUG);

                    //Si  une importation a été faite
                    if ($import) {
                        $importDone = TRUE;
                    }
                    //Si certain des fichiers ne se sont pas importés
                    if (count($digitalizedDocument->filenameError) > 0){
                        //
                        $importErrorFilename = array_merge($importErrorFilename, $digitalizedDocument->filenameError);
                        unset($digitalizedDocument->filenameError);
                        $digitalizedDocument->filenameError = array();
                    }
                    
                }
            }
        }
        
        //Si des fichiers ne se sont pas importés à cause d'une erreur
        if (count($importErrorFilename)>0){
            $importErrorFilename = sprintf(_("Liste des fichiers en erreur : %s"),implode(',',$importErrorFilename));
        }

        //Message de retour
        ($importDone) ?
            //Il y avait des documents à traiter 
            $this->setMessage(_("Tous les documents ont ete traites").
                ((!is_array($importErrorFilename) && $importErrorFilename!= '')?
					"\n".$importErrorFilename:
					"")) :
            //Il n'y avait aucun document à traiter
            $this->setMessage(_("Aucun document a traiter")) ;
        return $this->OK;
    }

    /**
     * Cette méthode permet de faire la purge des documents scannés
     * @param  string $data données envoyé en paramètre
     */
    public function purgeDigitalizedDocuments($data) {

        //Instance classe DigitalizedDocument
        require_once("../obj/digitalizedDocument.class.php");
        $digitalizedDocument = new DigitalizedDocument($this->f);

        // Récupère l'option "dossier_vide_uniquement"
        $dossier_vide_uniquement = isset($data["dossier_vide_uniquement"])?$data["dossier_vide_uniquement"]:false;

        //Dossier à purger
        $path = isset($data["dossier"])?$data["dossier"]:"";

        //Si aucun dossier n'est fourni, on utilise le dossier de configuration
        if($path==""){
            
            //Si le répertoire de numérisation n'est pas configuré
            if (!isset($this->f->config["path_scan"])) {
                //Message erreur
                $this->setMessage(_("Le repertoire de numerisation n'est pas configure"));
                $this->addToLog($this->msg, DEBUG_MODE);
                return $this->KO;
            }

            // Définit le chemin par défaut sur Done/
            $path = $this->f->config['path_scan'].'Done/';

            // Si l'option de purge des répertoires uniquement est activé
            if ($dossier_vide_uniquement === true
                || $dossier_vide_uniquement === "true") {
                // Définit le chemin par défaut sur Todo/
                $path = $this->f->config['path_scan'].'Todo/';
            }
        }
        //Si le dossier n'existe pas, on retourne une erreur
        elseif (!is_dir($path)) {
            //Message erreur
            $this->setMessage(_("Le repertoire de numerisation fourni n'existe pas"));
            $this->addToLog($this->msg, DEBUG_MODE);
            return $this->KO;
        }
        
        //Nombre de jour à soustraite à la date du jour
        $nbDay = isset($data["nombre_de_jour"])?$data["nombre_de_jour"]:"";
        //Vérifie que $nbDay soit un entier
        if (!is_numeric($nbDay)) {
            $nbDay = null;
        }

        // Nom des éléments traités
        $item = "fichier";
        if ($dossier_vide_uniquement === true
            || $dossier_vide_uniquement === 'true') {
            //
            $item = "dossier";
        }

        //
        $repo = scandir($path);

        //Si le dossier est ouvert
        if ($repo) {
            $count_purged_folder = 0;
            $count_purged_files = 0;
            //
            foreach ($repo as $key => $folder) {

                //Vérifie qu'il s'agit de dossier correct
                if ($folder != '.' && $folder != '..' && $folder != '.svn') {
                    
                    //Importation des documents
                    $purge = $digitalizedDocument->run_purge($path."/".$folder, $nbDay, $dossier_vide_uniquement);

                    //Si la purge n'a pas était faite
                    if ($purge != false) {
                        $count_purged_files += $purge;
                    }
                    $count_purged_folder++;

                }

            }
            //Retourne erreur
            $this->setMessage($count_purged_files." ".$item."(s) purgé(s) sur ".$count_purged_folder." dossier(s) traité(s)");
            $this->addToLog($this->msg, DEBUG_MODE);
            return $this->OK;
        }

        //Retourne erreur
        $this->setMessage("Aucun ".$item." à traiter");
        $this->addToLog($this->msg, DEBUG_MODE);
        return $this->OK;
    }

    /**
     * Cette fonction permet de mettre à jour les données des dossiers d'autorisation
     * pour la reprise des données.
     */
    public function majDAReprise($data) {

        $msg ="";
        $sql_dossier = "SELECT dossier_autorisation FROM ".DB_PREFIXE."dossier_autorisation
        LIMIT 1000 OFFSET ".intval($data["offset"]);

        $res_da = $this->db->query($sql_dossier);
        if ($this->f->isDatabaseError($res_da, true)) {
            $this->setMessage(_("Erreur de base de donnees."));
            return $this->KO;
        }
        require_once("../obj/dossier_autorisation.class.php");
        $i = 0;
        while($row = $res_da->fetchRow(DB_FETCHMODE_ASSOC)) {
            $da = new dossier_autorisation($row["dossier_autorisation"], $this->db, 0);

            if($da->majDossierAutorisation() !== true) {
                $msg .= "Erreur sur le dossier ".$row["dossier_autorisation"]."<br/>";
            } else {
                $i++;
            }
            
        }
        //Retourne message valid
        $this->setMessage(
            $i."|".$msg
        );
        return $this->OK;

    }
    
    /**
     * Cette fonction permet de mettre à jour les données techniques des dossiers
     * d'instruction.
     */
    public function majDTReprise($data) {
        
        $msg ="";
        $sql_di_sans_dt = "SELECT dossier, dossier.dossier_autorisation 
            FROM ".DB_PREFIXE."dossier
            LEFT OUTER JOIN ".DB_PREFIXE."donnees_techniques 
                ON dossier.dossier=donnees_techniques.dossier_instruction
            WHERE donnees_techniques.donnees_techniques IS NULL AND
            dossier.dossier_autorisation NOT IN (".rtrim($data, ", ").")
        LIMIT 1000 ";//OFFSET ".$data;

        $res_di_sans_dt = $this->db->query($sql_di_sans_dt);
        if ($this->f->isDatabaseError($res_di_sans_dt, true)) {
            $this->setMessage(_("Erreur de base de donnees."));
            return $this->KO;
        }
        
        $i = 0;
        while ( $row_di_sans_dt = $res_di_sans_dt->fetchrow(DB_FETCHMODE_ASSOC)) {
            $sql_dt = "SELECT donnees_techniques.donnees_techniques
                    FROM ".DB_PREFIXE."donnees_techniques
                    INNER JOIN ".DB_PREFIXE."dossier ON
                        dossier.dossier=donnees_techniques.dossier_instruction 
                    WHERE dossier.dossier = (
                        SELECT dossier.dossier
                        FROM ".DB_PREFIXE."dossier
                        JOIN ".DB_PREFIXE."avis_decision 
                            ON dossier.avis_decision = avis_decision.avis_decision
                        JOIN ".DB_PREFIXE."donnees_techniques 
                            ON donnees_techniques.dossier_instruction = dossier.dossier
                        WHERE  dossier.dossier_autorisation = '".$row_di_sans_dt['dossier_autorisation']."'
                            AND (date_decision IS NOT NULL
                            AND (avis_decision.typeavis='F'
                                OR avis_decision.typeavis='A')
                            OR version=0)
                    ORDER BY version DESC
                    LIMIT 1)";
            $res_dt = $this->f->db->getone($sql_dt);
            $this->f->addToLog("app/update_DA.php: db->query(\"".$sql_dt."\");", DEBUG_MODE);
            if ($this->f->isDatabaseError($res_dt, true)) {
                $this->setMessage(_("Erreur de base de donnees."));
                return $this->KO;
            }
            if(!empty($res_dt)) {
                $sql_data_dt = "SELECT *
                        FROM ".DB_PREFIXE."donnees_techniques
                        WHERE donnees_techniques.donnees_techniques = ".$res_dt;
                $res_data_dt = $this->f->db->query($sql_data_dt);
                $this->f->addToLog("app/update_DA.php: db->query(\"".$sql_data_dt."\");", DEBUG_MODE);
                if ($this->f->isDatabaseError($res_data_dt, true)) {
                    $this->setMessage(_("Erreur de base de donnees."));
                    return $this->KO;
                }

                $row_data_dt = $res_data_dt->fetchrow(DB_FETCHMODE_ASSOC);

                $row_data_dt['dossier_autorisation'] = null;
                $row_data_dt['dossier_instruction'] = $row_di_sans_dt['dossier'];
                foreach ($row_data_dt as $key => $value) {
                    if($value === '') {
                        unset($row_data_dt[$key]);
                    }
                }
                $row_data_dt['donnees_techniques'] = $this->f->db->nextId(DB_PREFIXE.'donnees_techniques');
                $res_ajout = $this->f->db->autoexecute(DB_PREFIXE."donnees_techniques", $row_data_dt, DB_AUTOQUERY_INSERT);
                $this->f->addToLog("app/update_DA.php : db->autoexecute(\"".DB_PREFIXE."donnees_techniques\", ".print_r($row_data_dt, true).", DB_AUTOQUERY_INSERT);", DEBUG_MODE);
                $this->f->isDatabaseError($res_ajout);
                $i++;
            } else {
                $msg .= "'".$row_di_sans_dt['dossier_autorisation']."', ";
            }
        }
        
        //Retourne message valid
        $this->setMessage(
            $i."|".$msg
        );
        return $this->OK;

    }

    /**
     * Cette fonction permet de mettre à jour l'état des dossiers d'autorisation
     */
    public function updateDAState() {

        // Récupération des DA dont l'état doit passer à "Périmé"
        $sql_da = "SELECT dossier_autorisation.dossier_autorisation

            FROM ".DB_PREFIXE."dossier_autorisation
            LEFT OUTER JOIN (
                    SELECT dossier_autorisation
                    FROM ".DB_PREFIXE."dossier
                    LEFT JOIN ".DB_PREFIXE."dossier_instruction_type
                        ON dossier_instruction_type.dossier_instruction_type = dossier.dossier_instruction_type
                    LEFT JOIN ".DB_PREFIXE."avis_decision
                        ON avis_decision.avis_decision = dossier.avis_decision
                    WHERE code IN ('DOC', 'DAACT') and
                        avis_decision.typeavis = 'F')
                AS dossier_2 on dossier_2.dossier_autorisation = dossier_autorisation.dossier_autorisation
            LEFT JOIN ".DB_PREFIXE."dossier
                ON dossier.dossier_autorisation = dossier_autorisation.dossier_autorisation
            LEFT JOIN ".DB_PREFIXE."dossier_instruction_type
                ON dossier.dossier_instruction_type = dossier_instruction_type.dossier_instruction_type
            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_type_detaille.dossier_autorisation_type_detaille = dossier_autorisation.dossier_autorisation_type_detaille
            
            WHERE etat_dossier_autorisation.libelle = 'Accordé'
                AND dossier_autorisation.date_decision IS NOT NULL
                AND etat_dossier_autorisation.libelle = 'Accordé'
                AND dossier_autorisation.date_validite < current_date
                AND dossier_2.dossier_autorisation IS NULL
            
            GROUP BY dossier_autorisation.dossier_autorisation";
        $res_da = $this->db->query($sql_da);
        if ($this->f->isDatabaseError($res_da, true)) {
            $this->setMessage(_("Erreur de base de donnees."));
            return $this->KO;
        }

        // Récupération de l'identifiant de l'état "Périmé"
        $sql_etat_perime = "SELECT etat_dossier_autorisation
                            FROM ".DB_PREFIXE."etat_dossier_autorisation 
                            WHERE libelle = 'Périmé'";
        $res_etat_perime = $this->db->getOne($sql_etat_perime);
        if ($this->f->isDatabaseError($res_etat_perime, true)) {
            $this->setMessage(_("Erreur de base de donnees."));
            return $this->KO;
        }

        // Liste des dossiers d'autorisation
        $ids = array();
        while ($row_da =& $res_da->fetchRow(DB_FETCHMODE_ASSOC)) {
            $ids[] = "'".$row_da['dossier_autorisation']."'";
        }

        // Si aucun dossier d'autorisation n'est concerné par le traitement alors on
        // ajoute un message d'informations et on retourne un résultat 'OK'
        if (count($ids) == 0) {
            $this->setMessage(_("Aucune mise a jour."));
            return $this->OK;
        }

        // Exécution du traitement
        // On met à jour tous les dossiers d'autorisations
        $fields = array(
            'etat_dossier_autorisation' => $res_etat_perime,
            'etat_dernier_dossier_instruction_accepte' => $res_etat_perime,
        );
        $res = $this->db->autoExecute(DB_PREFIXE."dossier_autorisation",
                                      $fields,
                                      DB_AUTOQUERY_UPDATE,
                                      'dossier_autorisation IN ('.implode(',', $ids).')');
        // Logger
        $this->addToLog("updateDAState(): db->autoExecute(\"".DB_PREFIXE."dossier_autorisation"."\", ".print_r($fields, true).", DB_AUTOQUERY_UPDATE, \"dossier_autorisation IN (\"".implode(',', $ids)."\")", VERBOSE_MODE);
        // Si une erreur de base de données se produit sur cette requête
        // alors on retourne un résultat d'erreur
        if ($this->f->isDatabaseError($res, true)) {
            $this->setMessage("Erreur de base de données.");
            return $this->KO;
        }

        // Tout s'est déroulé correctement alors on ajoute un message
        // d'informations et on retourne le résultat 'OK'
        $this->setMessage(count($ids)." "._("dossier(s) d'autorisation(s) mis a jour."));
        return $this->OK;

    }

    /**
     * Synchronisation des contraintes depuis le SIG
     * Permet d'ajouter de nouvelle contrainte, de modifier les contraintes
     * existantes et d'archiver les contraintes qui ne sont plus utilisées.
     */
    public function synchronisationContraintes() {

        // Instancie la classe SynchronisationContrainte
        require_once("../obj/synchronisationContrainte.class.php");
        $synchronisationContrainte = new SynchronisationContrainte($this->f);

        // Si la récupération des contraintes à fonctionnée
        if ($synchronisationContrainte->getResponseHTTP() == '200') {

            // Met à jour toutes les listes des contraintes
            $synchronisationContrainte->setAllListContraintes();

            // Initilisation des variables
            $error = false;
            $message = "";

            // Nombre de contrainte "à ajouter"
            $nb_contrainte_add = count(
                $synchronisationContrainte->getListContraintesAdd());
            // S'il y a des contraintes "à ajouter"
            if ($nb_contrainte_add > 0) {
                // Ajoute les contraintes "à ajouter"
                $ajouter = $synchronisationContrainte->addContraintes();
                // Si une erreur s'est produite
                if ($ajouter == false) {
                    //
                    $error = true;
                    $message .= _("une erreur s'est produite lors de l'ajout des nouvelles contraintes.")." "._("Contactez votre administrateur")."<br />";
                }
                // S'il n'y a pas d'erreur
                if ($ajouter == true) {
                    //
                    $message .= $nb_contrainte_add." "._("contrainte(s) ajoutee(s).");
                }
            // Sinon
            } else {
                //
                $message .= _("Aucune contraintes a ajouter.")."<br />";
            }

            // Nombre de contraintes "à modifier"
            $nb_contrainte_edit = count(
                $synchronisationContrainte->getListContraintesEdit());
            // S'il y a des contraintes "à modifier"
            if ($nb_contrainte_edit > 0) {
                // Modifie les contraintes "à modifier"
                $modifier = $synchronisationContrainte->editContraintes();
                // Si une erreur s'est produite
                if ($modifier == false) {
                    //
                    $error = true;
                    $message .= _("une erreur s'est produite lors de la modification des contraintes.")." "._("Contactez votre administrateur")."<br />";
                }
                // S'il n'y a pas d'erreur
                if ($modifier == true) {
                    //
                    $message .= $nb_contrainte_edit." "._("contrainte(s) modifiee(s).");
                }
            // Sinon
            } else {
                //
                $message .= _("Aucune contraintes a modifier.")."<br />";
            }

            // Nombre de contraintes "à archiver"
            $nb_contrainte_archive = count(
                $synchronisationContrainte->getListContraintesArchive());
            // S'il y a des contraintes "à archiver"
            if ($nb_contrainte_archive > 0) {
                // Archive les contraintes "à archiver"
                $archiver = $synchronisationContrainte->archiveContraintes();
                // Si une erreur s'est produite
                if ($archiver == false) {
                    //
                    $error = true;
                    $message .= _("une erreur s'est produite lors de l'archivage des contraintes.")." "._("Contactez votre administrateur")."<br />";
                }
                // S'il n'y a pas d'erreur
                if ($archiver == true) {
                    //
                    $message .= $nb_contrainte_archive." "._("contrainte(s) archivee(s).");
                }
            // Sinon
            } else {
                //
                $message .= _("Aucune contraintes a archiver.")."<br />";
            }

            //
            if ($error == false) {
                //
                $this->setMessage($message);
                return $this->OK;
            }

            // S'il y a une erreur
            if ($error == true) {
                //
                $this->setMessage($message);
                $this->addToLog("synchronisationContraintes(): ".$message, DEBUG_MODE);
                return $this->KO;
            }
        }

        // Si la récupération des contraintes n'a pas fonctionnée
        if ($synchronisationContrainte->getResponseHTTP() != '200') {
            //
            $this->addToLog("synchronisationContraintes(): Traitement webservice SIG: ".$soap->getErrorMessage(), DEBUG_MODE);
            //
            $this->setMessage("une erreur s'est produite.")." "._("Contactez votre administrateur")."<br />";
            //
            return $this->KO;
        }

    }

}

?>