trunk/obj/utils.class.php

<?php
/**
 * Ce fichier est destine a permettre la surcharge de certaines methodes de
 * la classe om_application pour des besoins specifiques de l'application
 *
 * @package openmairie_exemple
 * @version SVN : $Id: utils.class.php 547 2011-08-25 12:03:42Z fmichon $
 */

/**
 *
 */
require_once "../dyn/locales.inc.php";

/**
 *
 */
require_once "../dyn/include.inc.php";

/**
 *
 */
require_once "../dyn/debug.inc.php";

/**
 *
 */
(defined("PATH_OPENMAIRIE") ? "" : define("PATH_OPENMAIRIE", ""));

/**
 *
 */
require_once PATH_OPENMAIRIE."om_application.class.php";

/**
 *
 */
class utils extends application {

    // {{{
    
    /**
     * 
     */
    function isAccredited($obj = NULL, $operator = "AND") {
        // Lorsque l'utilisateur a le login 'admin' alors il est authorisé à
        // accéder à toutes les fonctions du logiciel
        // XXX à modifier pour changer ça vers un profil et non un login utilisateur
        if ($_SESSION["login"] == "admin") {
            return true;
        }
        // Fonctionnement standard
        return parent::isAccredited($obj, $operator);
    }
    
    // }}}

    // {{{

    var $om_utilisateur = array();
    var $user_is_instr = NULL;
    var $user_is_service = NULL;
    var $user_is_admin = NULL;
    var $user_is_service_ext = NULL;
    var $user_is_qualificateur = NULL;
    var $user_is_chef = NULL;
    var $user_is_divisionnaire = NULL;
    var $user_is_service_int = NULL;

    /**
     * Méthode de récupération des informations de l'utilisateur connecté.
     */
    function getUserInfos() {
        
        // Si l'utilisateur est loggé $_SESSION existe
        if(isset($_SESSION['login']) AND !empty($_SESSION['login'])) {
            
            // Récupération des infos utilisateur
            $sqlUser = "SELECT om_utilisateur, nom, email, login, om_collectivite, om_profil ".
            "FROM ".DB_PREFIXE."om_utilisateur WHERE login = '".$_SESSION['login']."'";
            $resUser=$this->db->query($sqlUser);
            $this->addToLog("getUserInfos(): db->query(\"".$sqlUser."\");", VERBOSE_MODE);
            if ( database::isError($resUser)){
                die();
            }
            $this->om_utilisateur=&$resUser->fetchRow(DB_FETCHMODE_ASSOC);

            // Récupère le profil et test si c'est un 
            $sqlProfil = "SELECT libelle FROM ".DB_PREFIXE."om_profil WHERE om_profil = ".$this->om_utilisateur['om_profil'];
            $resProfil=$this->db->getOne($sqlProfil);
            $this->addToLog("getUserInfos(): db->getOne(\"".$sqlProfil."\");", VERBOSE_MODE);
            if (database::isError($resProfil)){
                die();
            }
            // Sauvegarde le libelle du profil
            $this->om_utilisateur["libelle_profil"] = $resProfil;

            // si c'est un administrateur technique
            // XXX Mauvaise méthode, il faut utiliser isAccredited
            if ($resProfil == "ADMINISTRATEUR TECHNIQUE"
                || $resProfil == "ADMINISTRATEUR FONCTIONNEL") {
                $this->user_is_admin = true;
            } else {
                $this->user_is_admin = false;
            }

            //si c'est un service externe
            if ($resProfil == "SERVICE CONSULTÉ") {
                $this->user_is_service_ext = true;
            } else {
                $this->user_is_service_ext = false;
            }

            //si c'est un service interne
            if ($resProfil == "SERVICE CONSULTÉ INTERNE") {
                $this->user_is_service_int = true;
            } else {
                $this->user_is_service_int = false;
            }

            // si c'est un qualificateur
            if ($resProfil == "QUALIFICATEUR") {
                $this->user_is_qualificateur = true;
            } else {
                $this->user_is_qualificateur = false;
            }

            // si c'est un chef de service
            if ($resProfil == "CHEF DE SERVICE") {
                $this->user_is_chef = true;
            } else {
                $this->user_is_chef = false;
            }

            // si c'est un divisionnaire
            if ($resProfil == "DIVISIONNAIRE") {
                $this->user_is_divisionnaire = true;
            } else {
                $this->user_is_divisionnaire = false;
            }
            
            // Récupération des infos instructeur
            $sqlInstr = "SELECT instructeur.instructeur, instructeur.nom, instructeur.telephone,
            division.division, division.code, division.libelle ".
            "FROM ".DB_PREFIXE."instructeur INNER JOIN ".DB_PREFIXE."division ON division.division=instructeur.division ".
            "WHERE instructeur.om_utilisateur = ".$this->om_utilisateur['om_utilisateur'];
            $resInstr=$this->db->query($sqlInstr);
            $this->addToLog("getUserInfos(): db->query(\"".$sqlInstr."\");", VERBOSE_MODE);
            if ( database::isError($resInstr)){
                die();
            }
            $tempInstr=&$resInstr->fetchRow(DB_FETCHMODE_ASSOC);
            // Si il y a un resultat c'est un instructeur
            if(count($tempInstr)>0) {
                $this->user_is_instr=true;
                $this->om_utilisateur = array_merge($this->om_utilisateur,$tempInstr);
            } else {
                $this->user_is_instr=false;
            }
            
            // Récupération des infos de services consultés
            $sqlServ = "SELECT service.service, service.abrege, service.libelle ".
            "FROM ".DB_PREFIXE."service ".
            "INNER JOIN ".DB_PREFIXE."lien_service_om_utilisateur ON lien_service_om_utilisateur.service=service.service ".
            "WHERE lien_service_om_utilisateur.om_utilisateur = ".$this->om_utilisateur['om_utilisateur'];
            $resServ=$this->db->query($sqlServ);
            $this->addToLog("getUserInfos(): db->query(\"".$sqlServ."\");", VERBOSE_MODE);
            if ( database::isError($resServ)){
                die();
            }
            
            while ($tempServ=&$resServ->fetchRow(DB_FETCHMODE_ASSOC)) {
                $this->om_utilisateur['service'][]=$tempServ;
            }
            // Si il y a un resultat c'est un utilisateur de service
            if(isset($this->om_utilisateur['service'])) {
                $this->user_is_service=true;
            } else {
                $this->user_is_service=false;
            }
        }
    }

    /**
     * getter user_is_service
     */
    function isUserService() {
        //
        if (is_null($this->user_is_service)) {
            //
            $this->getUserInfos();
        }
        //
        return $this->user_is_service;
    }

    /**
     * getter user_is_instr
     */
    function isUserInstructeur() {
        //
        if (is_null($this->user_is_instr)) {
            //
            $this->getUserInfos();
        }
        //
        return $this->user_is_instr;
    }

    function isUserAdministrateur() {
        //
        if (is_null($this->user_is_admin)) {
            //
            $this->getUserInfos();
        }
        //
        return $this->user_is_admin;
    }

    /**
     * getter user_is_service_ext
     */
    function isUserServiceExt() {
        //
        if (is_null($this->user_is_service_ext)) {
            //
            $this->getUserInfos();
        }
        //
        return $this->user_is_service_ext;
    }

    /**
     * getter user_is_service_int
     */
    function isUserServiceInt() {
        //
        if (is_null($this->user_is_service_int)) {
            //
            $this->getUserInfos();
        }
        //
        return $this->user_is_service_int;
    }

    /**
     * getter user_is_qualificateur
     */
    function isUserQualificateur() {
        //
        if (is_null($this->user_is_qualificateur)) {
            //
            $this->getUserInfos();
        }
        //
        return $this->user_is_qualificateur;
    }

    /**
     * getter user_is_chef
     */
    function isUserChef() {
        //
        if (is_null($this->user_is_chef)) {
            //
            $this->getUserInfos();
        }
        //
        return $this->user_is_chef;
    }

    /**
     * getter user_is_divisionnaire
     */
    function isUserDivisionnaire() {
        //
        if (is_null($this->user_is_divisionnaire)) {
            //
            $this->getUserInfos();
        }
        //
        return $this->user_is_divisionnaire;
    }

    // Ajout de variables de session contenant la division pour permettre une
    // utilisation plus efficace dans les requetes
    function triggerAfterLogin($utilisateur = NULL) {
        //
        $sql = "SELECT instructeur.division, division.code
        FROM ".DB_PREFIXE."instructeur
        LEFT JOIN ".DB_PREFIXE."division
        ON instructeur.division = division.division
        WHERE instructeur.om_utilisateur='".$utilisateur["om_utilisateur"]."'";
        $res = $this->db->query($sql);
        $this->addToLog("triggerAfterLogin(): db->query(\"".$sql."\");", VERBOSE_MODE);
        if ( database::isError($res)){
            die();
        }
        $row = $res->fetchrow(DB_FETCHMODE_ASSOC);
        //
        if (isset($row["division"]) && $row["division"] != NULL) {
            $_SESSION["division"] = $row["division"];
            $_SESSION["division_code"] = $row["code"];
        } else {
            $_SESSION["division"] = "0";
            $_SESSION["division_code"] = "";
        }

    }    

    // Affichage des actions supplémentaires
    function displayActionExtras() {
        // Affichage de la division si l'utilisateur en possède une
        if ($_SESSION["division"] != 0) { 
            echo "\t\t\t<li class=\"action-division\">";
            echo "(".$_SESSION['division_code'].")";
            echo "</li>\n";
        }
    }

    // }}}

    
    function getDivisionFromDossier($dossier) {
        //
        $sql = "select division from ".DB_PREFIXE."dossier ";
        $sql .= " where dossier='".$dossier."'";
        //
        $division = $this->db->getOne($sql);
        $this->addToLog("getDivisionFromDossier(): db->getone(\"".$sql."\")", VERBOSE_MODE);
        database::isError($division);
        //
        return $division;
    }

    // {{{ GESTION DES FICHIERS
    
    /**
     *
     */
    function notExistsError ($explanation = NULL) {
        // message
        $message_class = "error";
        $message = _("Cette page n'existe pas.");
        $this->addToMessage ($message_class, $message);
        //
        $this->setFlag(NULL);
        $this->display();
        
        //
        die();
    }
    
     // }}}
    /**
     * Retourne le statut du dossier d'instruction
     * @param string $idx Identifiant du dossier d'instruction
     * @return string Le statut du dossier d'instruction
     */
    function getStatutDossier($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 d'instruction
            $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->addToLog("getStatutDossier() : db->getOne(\"".$sql."\")", VERBOSE_MODE);
            if ( database::isError($statut)){
                die();
            }
        }
        return $statut;
    }

    /**
     * Formate le champ pour le type Timestamp
     * @param  date  $date_str          Date
     * @param  boolean $show            Format pour l'affichage
     * @return mixed                    False si le traitement échoue ou la date formatée
     */
    function formatTimestamp ($date_str, $show = true) {

        // Sépare la date et l'heure
        $date = explode(" ", $date_str);
        if (count($date) != 2) {
            return false;
        }

        // Date en BDD
        $date_db = explode ('-', $date[0]);
                // Date en affichage
        $date_show = explode ('/', $date[0]);

        // Contrôle la composition de la date
        if (count ($date_db) != 3 and count ($date_show) != 3) {
            return false;
        }

        if (count ($date_db) == 3) {
            // Vérifie que c'est une date valide
            if (!checkdate($date_db[1], $date_db[2], $date_db[0])) {
                return false;
            }
            // Si c'est pour l'affichage de la date
            if ($show == true) {
                return $date_db [2]."/".$date_db [1]."/".$date_db [0]." ".$date[1];
            } else {
                return $date[0];
            }
        }

        //
        if (count ($date_show) == 3) {
            // Vérifie que c'est une date valide
            if (!checkdate($date_show[1], $date_show[0], $date_show[2])) {
                return false;
            }
            // Si c'est pour l'affichage de la date
            if ($show == true) {
                return $date[0];
            } else {
                return $date_show [2]."-".$date_show [1]."-".$date_show [0]." ".$date[1];
            }

        }
        return false;

    }

    /**
     * Permet de calculer la liste des parcelles à partir de la chaîne passée en paramètre
     * et la retourner sous forme d'un tableau associatif
     * 
     * @param  string $strParcelles chaîne de la parcelles 
     * @return array (array(quartier, section, parcelle), ...)
     */
    function parseParcelles($strParcelles) {
        
        // Séparation des lignes
        $references = explode(";", $strParcelles);
        $liste_parcelles = array();
        
        // On boucle sur chaque ligne pour ajouter la liste des parcelles de chaque ligne
        foreach ($references as $parcelles) {
            
            // On transforme la chaîne de la ligne de parcelles en tableau
            $ref = str_split($parcelles);
            // Les 1er caractères sont numériques
            $num = true;
            
            // Tableau des champs de la ligne de références cadastrales
            $reference_tab = array();
            $temp = "";
            foreach ($ref as $carac) {
                
                // Permet de tester si le caractère courant est de même type que le précédent
                if(is_numeric($carac) === $num) {
                    $temp .= $carac;
                } else {
                    // Bascule
                    $num = !$num;
                    // On stock le champ
                    $reference_tab[] = $temp;
                    // re-init de la valeur temporaire pour le champ suivant
                    $temp = $carac;
                }
            }
            // Stockage du dernier champ sur lequel il n'y a pas eu de bascule
            $reference_tab[] = $temp;
            // Calcul des parcelles
            $quartier = $reference_tab[0];
            $sect = $reference_tab[1];

            $ancien_ref_parc = "";
            for ($i=2; $i < count($reference_tab); $i+=2) { 
                $parc["quartier"] = $quartier;
                // Met en majuscule si besoin
                $parc["section"] = strtoupper($sect);
                if( $ancien_ref_parc == "" OR $reference_tab[$i-1] == "/") {
                    // 1ere parcelle ou parcelle individuelle
                    // Compléte par des "0" le début de la chaîne si besoin
                    $parc["parcelle"] = str_pad($reference_tab[$i], 4, "0", STR_PAD_LEFT);
                    // Ajout d'une parcelle à la liste
                    $liste_parcelles[] = $parc;
                } elseif ($reference_tab[$i-1] == "A") {
                    // Interval de parcelles
                    for ($j=$ancien_ref_parc+1; $j <= $reference_tab[$i]; $j++) {
                        // Compléte par des "0" le début de la chaîne si besoin
                        $parc["parcelle"] = str_pad($j, 4, "0", STR_PAD_LEFT);
                        // Ajout d'une parcelle à la liste
                        $liste_parcelles[] = $parc;
                    }
                }
                //Gestion des erreurs
                else{
                    
                    echo _("Une erreur de formattage a ete detecte dans la reference cadastrale du dossier ").$this->row['dossier'];
                }
                // Sauvegarde de la référence courante de parcelle
                $ancien_ref_parc = $reference_tab[$i];
            }
        }

        return $liste_parcelles;
    }

    /**
     * Formate les parcelles en ajoutant le code impôt
     * @param  array    $liste_parcelles   Tableau des parcelles
     * @return string                      Liste des parcelles formatées
     */
    function formatParcelleToSend($liste_parcelles) {

        //
        $wParcelle = array();

        //Formatage des références cadastrales pour l'envoi
        foreach ($liste_parcelles as $value) {
                
            // On ajoute les données dans le tableau que si quartier + section + parcelle
            // a été fourni
            if ($value["quartier"] !== ""
                && $value["section"] !== ""
                && $value["parcelle"] !== ""){
                
                //On récupère le code impôt de l'arrondissement
                $arrondissement = $this->getCodeImpotByQuartier($value["quartier"]);
                
                //On ajoute la parcelle, si un arrondissement a été trouvé
                if ($arrondissement!=="") {
                    //
                    $wParcelle[] = $arrondissement.$value["quartier"]." ".
                        $value["section"].$value["parcelle"];

                }
            }
        }

        //
        return $wParcelle;
    }

    /**
     * Récupère le code impôt par rapport au quartier
     * @param  string $quartier Numéro de quartier
     * @return string           Code impôt
     */
    function getCodeImpotByQuartier($quartier) {

        $arrondissement = "";

        // Si le quartier fournis est correct
        if ($quartier != "") {

            // Requête SQL
            $sql = "SELECT
                        arrondissement.code_impots
                    FROM
                        ".DB_PREFIXE."arrondissement
                    LEFT JOIN
                        ".DB_PREFIXE."quartier
                        ON
                            quartier.arrondissement = arrondissement.arrondissement 
                    WHERE
                        quartier.code_impots = '".$quartier."'";
            $this->addToLog("getCodeImpotByQuartier() : db->getOne(\"".$sql."\")", VERBOSE_MODE);
            $arrondissement = $this->db->getOne($sql);
            $this->isDatabaseError($arrondissement);
        }

        // Retour
        return $arrondissement;
    }

    /**
     * Vérification des paramètres
     */
    function checkParams() {
        parent::checkParams();

        (isset($this->config['path_scan']) ? "" : $this->config['path_scan'] = '../trs/numerisation/');
        
        $default_sig_elyx = array(
            'wsdl' => '../tests/wsurbanisme.wsdl',
            'login' => 'sig',
            'password' => 'sig',
        );
        (isset($this->config['sig_elyx']) ? "" : $this->config['sig_elyx'] = $default_sig_elyx);
    }

    /**
     * Retourne true si tous les paramètres du SIG externe ont bien été définis
     * @return bool true/false
     */
    public function issetSIGParameter() {
        if($this->getParameter("sig_web_server") != NULL AND
            $this->getParameter("sig_web_server") != "" AND
            $this->getParameter("sig_couche_emprise_dossier") != NULL AND
            $this->getParameter("sig_couche_emprise_dossier") != "" AND
            $this->getParameter("sig_couche_affichage_dossier") != NULL AND
            $this->getParameter("sig_couche_affichage_dossier") != "" AND
            $this->getParameter("sig_couche_affichage_parcelle") != NULL AND
            $this->getParameter("sig_couche_affichage_parcelle") != "") {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Permet de vérifier que des champs existe dans une table
     * @param  array  $list_fields Liste des champs à tester
     * @param  string $table       Table où les champs doivent exister
     * @return mixed               Retourne les champs qui n'existent pas
     *                             ou true
     */
    public function check_field_exist($list_fields, $table) {

        // Requête SQL pour récupérer le nom des colonnes
        $sql = "SELECT column_name
                FROM information_schema.columns
                WHERE table_schema = '".substr(DB_PREFIXE, 0, -1)."'
                AND table_name = '".$table."'
                ORDER BY ordinal_position";
        $this->addToLog("check_field_exist() : db->query(\"".$sql."\")", VERBOSE_MODE);
        $res = $this->db->query($sql);
        $this->isDatabaseError($res);

        // Tant qu'il y a un résultat
        while ($row = &$res->fetchRow(DB_FETCHMODE_ASSOC)) {
            
            // Le nom de la colonne est mise dans un tableau
            $list_column[] = $row['column_name'];
        }

        // Tableau des champs en erreur
        $error_fields = array();

        // Pour chaque champ à tester
        foreach ($list_fields as $value) {
            
            // S'il n'apparaît pas dans la liste des champs possible
            if (!in_array($value, $list_column)) {

                // Alors le champ est ajouté au tableau des erreurs
                $error_fields[] = $value;
            }
        }

        // Si le tableau des erreurs n'est pas vide on le retourne
        if (count($error_fields) > 0) {
            return $error_fields;
        }

        // Sinon on retourne le booléen true
        return true;

    }

    /*
     * 
     */
    /**
     * Récupère la lettre type lié à un événement
     * @param  integer  $evenement L'identifiant de l'événement
     * @return integer             Retourne l'idenfiant de la lettre-type                             ou true
     */
    function getLettreType($evenement){
         
         $lettretype = NULL;
         
         $sql = 
            "SELECT
                lettretype
            FROM
                ".DB_PREFIXE."evenement
            WHERE
                evenement = $evenement";
            
        $this->addToLog("getLettreType() : db->query(\"".$sql."\")", VERBOSE_MODE);
        $res = $this->db->query($sql);
        if ( database::isError($res)){
            die();
        }
        
        if ( $res->numrows() > 0 ){
                
            $row=& $res->fetchRow(DB_FETCHMODE_ASSOC);
            $lettretype = $row['lettretype'];
        }
       
        return $lettretype;
    }
    
    /**
     * Retourne le type de dossier d'autorisation du dossier courant :
     * @param $idxDossier Le numéro du dossier d'instruction
     * @return le code du type détaillée de dossier d'autorisation
     **/
    function getDATDCode($idxDossier) {
        $sql = "SELECT dossier_autorisation_type_detaille.code
                FROM ".DB_PREFIXE."dossier_autorisation_type_detaille
                INNER JOIN ".DB_PREFIXE."dossier_autorisation
                    ON dossier_autorisation_type_detaille.dossier_autorisation_type_detaille =
                       dossier_autorisation.dossier_autorisation_type_detaille
                INNER JOIN ".DB_PREFIXE."dossier ON dossier.dossier_autorisation = dossier_autorisation.dossier_autorisation
                WHERE dossier.dossier = '".$idxDossier."'";
        $res = $this->db->getOne($sql);
        $this->addToLog("getDATDCode() : db->getOne(\"".$sql."\")", VERBOSE_MODE);
        if ( database::isError($res)){
            die();
        }
        return $res;
    }

    /**
     * Permet de copier un enregistrement
     * @param  mixed $idx   Identifiant de l'enregistrment
     * @param  string $obj   Objet de l'enregistrment
     * @param  string $objsf Objets associés
     * @return array        Tableau des nouveaux id et du message
     */
    function copier($idx, $obj, $objsf) {

        // Tableau de résultat
        $resArray = array();
        // Message retourné à l'utilisateur
        $message = "";
        // Type du message (valid ou error)
        $message_type = "valid";

        // Requête SQL permettant de récupérer les informations sur l'objet métier
        $sql = "SELECT * 
                FROM ".DB_PREFIXE.$obj." 
                WHERE ".$obj." = ".$idx;
        $res = $this->db->query($sql);
        $this->isDatabaseError($res);

        // Valeurs clonées
        $valF = array();
        while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
            // Recupère la valeur
            $valF = $row;
        }

        // Valeurs non clonées
        // Identifiant modifié pour que ça soit un ajout
        $valF[$obj] = "]";

        // Inclus la classe de l'objet métier
        require_once "../obj/".$obj.".class.php";

        // Instance de l'objet métier
        $clone_obj = new $obj("]", $this->db, DEBUG);
        // Si dans l'objet métier la fonction "copier" existe
        if (method_exists($clone_obj, "copier")) {
            // Traitement sur les valeurs du duplicata
            $valF = $clone_obj->copier($valF, $objsf, DEBUG);
            // Recupère les messages retourné par la fonction
            $message .= $valF['message'];
            // Supprime les messages de la liste des valeurs
            unset($valF['message']);
        }
        // Ajoute le duplicata
        $clone_obj->ajouter($valF, $this->db, DEBUG);
        // Si aucune erreur se produit dans la classe instanciée
        if ($clone_obj->correct === true) {
            // Récupère l'identifiant de l'objet créé
            $clone_obj_id = $clone_obj->valF[$obj];

            // Message
            $message .= sprintf(_("La copie de l'enregistrement %s avec l'identifiant %s s'est effectuee avec succes"), "<span class='bold'>"._($obj)."</span>", "<span class='bold'>".$idx."</span>")."<br />";

            // Ajout de l'identifant au tableau des résultat
            $resArray[$obj.'_'.$idx] = $clone_obj_id;

            // S'il y a au moins un objet metier associé
            if ($objsf != "") {
                // Liste des objet métier associés
                $list_objsf = explode(",", $objsf);
                // Pour chaque objet associé
                foreach ($list_objsf as $key => $objsf) {
                    // Inclus la classe de l'objet métier associé
                    require_once "../obj/".$objsf.".class.php";

                    // Requête SQL permettant de récupérer les informations sur 
                    // l'objet métier associé
                    $sql = "SELECT * 
                            FROM ".DB_PREFIXE.$objsf." 
                            WHERE ".$obj." = ".$idx;
                    $res = $this->db->query($sql);
                    $this->isDatabaseError($res);                    

                    // Pour chaque élément associé
                    while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
                        // Identifiant de l'objet associé à copier
                        $idxsf = $row[$objsf];

                        // Valeurs clonées
                        $valF = $row;
                        // Valeurs non clonées
                        $valF[$obj] = $clone_obj_id;
                        // Identifiant modifié pour que ça soit un ajout
                        $valF[$objsf] = "]";
                        // Instance de l'objet métier associé
                        $clone_objsf = new $objsf("]", $this->db, DEBUG);
                        // Si dans l'objet métier associé 
                        // la fonction "copier" existe
                        if (method_exists($clone_objsf, "copier")) {
                            // Traitement sur les valeurs du duplicata
                            $valF = $clone_objsf->copier($valF, $objsf, DEBUG);
                            // Recupère les messages retourné par la fonction
                            $message .= $valF['message'];
                            // Supprime les messages de la liste des valeurs
                            unset($valF['message']);
                        }
                        // Ajoute le duplicata
                        $clone_objsf->ajouter($valF, $this->db, DEBUG);
                        // Si aucune erreur se produit dans la classe instanciée
                        if ($clone_objsf->correct === true) {
                            // Récupère l'identifiant de l'objet créé
                            $clone_objsf_id = $clone_objsf->valF[$objsf];

                            // Message
                            $message .= sprintf(_("La copie de l'enregistrement %s avec l'identifiant %s s'est effectuee avec succes"), "<span class='bold'>"._($objsf)."</span>", "<span class='bold'>".$idxsf."</span>")."<br />";

                            // Ajout de l'identifant au tableau des résultat
                            $resArray[$objsf.'_'.$row[$objsf]] = $clone_objsf_id;
                        } else {

                            // Message d'erreur récupéré depuis la classe
                            $message .= $clone_objsf->msg;
                            // Type du message 
                            $message_type = "error";
                        }
                    }
                }
            }
        //    
        } else {

            // Message d'erreur récupéré depuis la classe
            $message .= $clone_obj->msg;
            // Type du message 
            $message_type = "error";
        }

        // Ajout du message au tableau des résultats
        $resArray['message'] = $message;
        // Ajout du type de message au tableau des résultats
        $resArray['message_type'] = $message_type;

        // Retourne le tableau des résultats
        return $resArray;
    }

    /**
     * Permet de détailler les conditions pour l'affichage des contraintes dans
     * une édition.
     * @param string $contraintes_param    Chaine des conditions
     * 
     * @return array                        Conditions
     */
    function explodeConditionContrainte($contraintes_param) {

        // Initialisation des variables
        $return = array();
        $listGroupes = "";
        $listSousgroupes = "";
        $service_consulte = "";

        // Coupe la condition au ";"
        // Doit séparer groupe et sous-groupe
        $contraintes_params = explode(";", $contraintes_param);
        
        // Pour chaque paramètres
        foreach ($contraintes_params as $value) {
            // Si le mot-clés "liste_groupe="
            if (strstr($value, "liste_groupe=")) { 
                // On enlève le mots-clés "liste_groupe="
                $listGroupes = str_replace("liste_groupe=", "", $value);
            }
            // Si le mot-clés "liste_ssgroupe="
            if (strstr($value, "liste_ssgroupe=")) { 
                // On enlève le mots-clés "liste_ssgroupe="
                $listSousgroupes = str_replace("liste_ssgroupe=", "", $value);
            }
            // Si le mot-clés "service_consulte="
            if (strstr($value, "service_consulte=")) { 
                // On enlève le mots-clés "service_consulte="
                $service_consulte = str_replace("service_consulte=", "", $value);
            }
        }

        // Récupère la liste des groupes et sous-groupes qui doivent 
        // être utilisés pour la condition
        if ($listGroupes != "") {
            $listGroupes = explode(",", $listGroupes);
        }
        if ($listSousgroupes != "") {
            $listSousgroupes = explode(",", $listSousgroupes);
        }

        // Tableau à retourner
        $return['groupes'] = $listGroupes;
        $return['sousgroupes'] = $listSousgroupes;
        $return['service_consulte'] = $service_consulte;

        //
        return $return;
    }

    /**
     * Traitement pour créer la condition sur les contraintes dans les éditions.
     * @param string $part SQL et parti du pdf (sql, titre ou corps)
     * 
     * @return string      Condition pour la requête sur les contraintes
     */
    function traitement_condition_contrainte($part) {

        // Initialisationd de la condition
        $whereContraintes = "";

        // Détaille la condtion
        $explodeConditionContrainte = $this->explodeConditionContrainte($part);

        // Récupère les groupes, sous-groupes et service_consulte pour la condition
        $groupes = $explodeConditionContrainte['groupes'];
        $sousgroupes = $explodeConditionContrainte['sousgroupes'];
        $service_consulte = $explodeConditionContrainte['service_consulte'];

        // Pour chaque groupe
        if ($groupes != "") {
            foreach ($groupes as $key => $groupe) {
                // Si le groupe n'est pas vide
                if (!empty($groupe)) {
                    // Choisit l'opérateur logique
                    $op_logique = $key > 0 ? 'OR' : 'AND (';
                    // Ajoute la condition 
                    $whereContraintes .= " ".$op_logique." contrainte.groupe = '"
                        .$groupe."'";
                }
            }
            // S'il y a des valeurs dans groupe
            if (count($groupe) > 0) {
                // Ferme la parenthèse
                $whereContraintes .= " ) ";
            }
        }

        // Pour chaque sous-groupe
        if ($sousgroupes != "") {
            foreach ($sousgroupes as $key => $sousgroupe) {
                // Si le sous-groupe n'est pas vide
                if (!empty($sousgroupe)) {
                    // Choisit l'opérateur logique
                    $op_logique = $key > 0 ? 'OR' : 'AND (';
                    // Ajoute la condition
                    $whereContraintes .= " ".$op_logique." contrainte.sousgroupe = '"
                        .$sousgroupe."'";
                }
            }
            // S'il y a des valeurs dans sous-groupe
            if (count($sousgroupes) > 0) {
                // Ferme la parenthèse
                $whereContraintes .= " ) ";
            }
        }

        // Si l'option service_consulte n'est pas vide
        if ($service_consulte != "") {
            // Ajoute la condition
            $whereContraintes .= " AND service_consulte = '".$service_consulte."'";
        }

        // Condition retournée
        return $whereContraintes;
    }

    /**
     * Calcule une date par l'ajout ou la soustraction de mois
     * @param date    $date     Date de base
     * @param integer $delay    Délais à ajouter (en mois)
     * @param string  $operator Opérateur pour le calcul ("-" ou "+")
     * 
     * @return date             Date calculée
     */
    function mois_date($date, $delay, $operator = "+") {

        // Découpage de la date
        $temp = explode("-" , $date);
        $day = (int) $temp[2];
        $month = (int) $temp[1];
        $year = (int) $temp[0];

        // Si c'est une addition
        if ($operator == '+') {
            // Si le délais est supérieur à 12 mois
            if ($delay >= 12) {
                // Année à ajouter
                $year += floor($delay / 12);
                // Mois restant
                $nb_month = ($delay % 12);
                // S'il y a des mois restant
                if ($nb_month != 0) {
                    // Ajout des mois restant
                    $month += $nb_month;
                    // Si ça dépasse le mois 12 (décembre)
                    if ($month > 12) {
                        // Soustrait 12 au mois
                        $month -= 12;
                        // Ajoute 1 à l'année
                        $year += 1;
                    }
                }
            } else {
                // Ajoute le délais
                $month += $delay;
                // Si ça dépasse le mois 12 (décembre)
                if ($month > 12) {
                    // Soustrait 12 au mois
                    $month -= 12;
                    // Ajoute 1 à l'année
                    $year += 1;
                }
            }
        }

        // Si c'est une soustraction
        if ($operator == "-") {
            // Si le délais est supérieur à 12 mois
            if ($delay >= 12) {
                // Année à soustraire
                $year -= floor($delay / 12);
                // Mois restant
                $nb_month = ($delay % 12);
                // S'il y a des mois restant
                if ($nb_month != 0) {
                    // Soustrait le délais
                    $month -= $nb_month;
                    // Si ça dépasse le mois 1 (janvier)
                    if ($month < 1) {
                        // Soustrait 12 au mois
                        $month += 12;
                        // Ajoute 1 à l'année
                        $year -= 1;
                    }
                }
            } else {
                // Soustrait le délais
                $month -= $delay;
                // Si ça dépasse le mois 1 (janvier)
                if ($month < 1) {
                    // Soustrait 12 au mois
                    $month += 12;
                    // Ajoute 1 à l'année
                    $year -= 1;
                }
            }
        }

        // Calcul du nombre de jours dans le mois sélectionné
        switch($month) {
            // Mois de février
            case "2":
                if ($year % 4 == 0 && $year % 100 != 0 || $year % 400 == 0) {
                    $day_max = 29;
                } else {
                    $day_max = 28;
                }
            break;
            // Mois d'avril, juin, septembre et novembre
            case "4":
            case "6":
            case "9":
            case "11":
                $day_max = 30;
            break;
            // Mois de janvier, mars, mai, juillet, août, octobre et décembre 
            default:
                $day_max = 31;
        }

        // Si le jour est supérieur au jour maximum du mois
        if ($day > $day_max) {
            // Le jour devient le jour maximum
            $day = $day_max;
        }

        // Retourne la date calculée
        return $year."-".$month."-".$day ;
    }
}

?>