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

// Inclusion de la classe de base MetierManager
require_once("./metier/metiermanager.php");
// Classes métier
require_once("../obj/demandeur.class.php");
require_once("../obj/demande.class.php");


/**
 * Cette classe hérite de MetierManager. Elle permet de créer des demandes, de
 * la même manière qu'une demande aurait été créée par l'interface : les dossiers
 * d'autorisation, dossiers d'instruction et demandeurs liés sont aussi créés (si 
 * applicable).
 */
class diamanager extends MetierManager {


    // Identifiant de la collectivité de la demande
    private $collectivite = array();


    /**
     * Méthode principale qui gère le processus entier de création de demande :
     *  - création du ou des demandeurs
     *  - création d'une nouvelle demande ou demande sur existant
     *
     * @param array $request_data Les données brutes de la demande sous forme
     * de tableau associatif :
     * array(
     *     'demande' => array(
     *         'demande_type' => '...',
     *         'date_demande' => '...',
     *         [...]
     *      ),
     *     'petitionnaire_principal' => array(
     *         'particulier_nom' => '...',
     *         [...]
     *      ),
     *     'autres_demandeurs' => array(...)
     * )
     * @return string Le résultat du traitement
     */
    public function create($request_data) {
        $this->f = new utils("nohtml");
        $this->f->disableLog();

        $_POST = array();

        // Champs obligatoires "demande_type",
        // "dossier_autorisation_type_detaille" et "om_collectivite"
        if (array_key_exists("demande_type", $request_data) === false) {
            $this->setMessage(_("Le format des données fournies en paramètre est incorrect."));
            return $this->BAD_DATA;
        }
        if (array_key_exists("dossier_autorisation_type_detaille", $request_data) === false) {
            $this->setMessage(_("Le format des données fournies en paramètre est incorrect."));
            return $this->BAD_DATA;
        }
        if (array_key_exists("om_collectivite", $request_data) === false) {
            $this->setMessage(_("Le format des données fournies en paramètre est incorrect."));
            return $this->BAD_DATA;
        }
        if (array_key_exists("date_demande", $request_data) === false) {
            $this->setMessage(_("Le format des données fournies en paramètre est incorrect."));
            return $this->BAD_DATA;
        }

        // Ajout de demande sur existant
        if (isset($request_data["dossier_instruction"]) === true && $request_data["dossier_instruction"] !== '') {
            // Retraitement spécifique des données de la demande sur existant
            $demande_values = $this->prepare_demande_existant_data($request_data);
            if ($demande_values === false) {
                $this->setMessage(_("Erreur lors de la création de la demande.") . " " . $this->getMessage());
                return $this->BAD_DATA;
            }
        }
        // Ajout d'une nouvelle demande
        else {
            // Retraitement spécifique des données de la nouvelle demande
            $demande_values = $this->prepare_new_demande_data($request_data);
            if ($demande_values === false) {
                $this->setMessage(_("Erreur lors de la création de la demande.") . " " . $this->getMessage());
                return $this->BAD_DATA;
            }

            // Les données vides saisies en RobotFramework peuvent être définies de
            // différentes manières : dictionnaire vide, ${EMPTY}, ${NULL}, null
            // On prend ici en compte tous les cas pour faciliter l'écriture des tests
            if ($request_data !== null
                && $request_data !== "null"
                && $request_data !== ""
                && $request_data !== array()) {
                $request_data = $request_data;
            }

            // // Ajout des demandeurs
            // foreach ($request_data as $demandeur_type => $demandeur_valeur) {
            //     $demandeur_id = $this->creation_demandeur($demandeur_type, $demandeur_valeur);
            //     if ($demandeur_id === false) {
            //         $this->setMessage(_("Erreur de demandeur: ") . $demandeur_type . ": " . $this->getMessage());
            //         return $this->BAD_DATA;
            //     }

            //     if (array_key_exists($demandeur_type, $_POST) == false) {
            //         $_POST[$demandeur_type] = array();
            //     }
            //     $_POST[$demandeur_type][] = $demandeur_id;
            // }

            // Permet d'ajouter le pétitionnaire principale qui dans le cas des
            // DIA est le propriétaire/vendeur
            $demandeur_valeur = array();
            $demandeur_id = false;
            $demandeur_type = null;
            $demandeur_valeur['particulier_civilite'] = (isset($request_data['petitionnaire_principal_particulier_civilite']) === true) ? $request_data['petitionnaire_principal_particulier_civilite'] : "";
            $demandeur_valeur['particulier_nom'] = (isset($request_data['petitionnaire_principal_particulier_nom']) === true) ? $request_data['petitionnaire_principal_particulier_nom'] : "";
            $demandeur_valeur['particulier_prenom'] = (isset($request_data['petitionnaire_principal_particulier_prenom']) === true) ? $request_data['petitionnaire_principal_particulier_prenom'] : "";
            $demandeur_valeur['particulier_date_naissance'] = (isset($request_data['petitionnaire_principal_particulier_date_naissance']) === true) ? $request_data['petitionnaire_principal_particulier_date_naissance'] : "";
            $demandeur_valeur['particulier_commune_naissance'] = (isset($request_data['petitionnaire_principal_particulier_commune_naissance']) === true) ? $request_data['petitionnaire_principal_particulier_commune_naissance'] : "";
            $demandeur_valeur['particulier_departement_naissance'] = (isset($request_data['petitionnaire_principal_particulier_departement_naissance']) === true) ? $request_data['petitionnaire_principal_particulier_departement_naissance'] : "";
            $demandeur_valeur['om_collectivite'] = (isset($request_data['om_collectivite']) === true) ? $request_data['om_collectivite'] : "";
            $demandeur_valeur['numero'] = (isset($request_data['petitionnaire_principal_numero']) === true) ? $request_data['petitionnaire_principal_numero'] : "";
            $demandeur_valeur['voie'] = (isset($request_data['petitionnaire_principal_voie']) === true) ? $request_data['petitionnaire_principal_voie'] : "";
            $demandeur_valeur['complement'] = (isset($request_data['petitionnaire_principal_complement']) === true) ? $request_data['petitionnaire_principal_complement'] : "";
            $demandeur_valeur['lieu_dit'] = (isset($request_data['petitionnaire_principal_lieu_dit']) === true) ? $request_data['petitionnaire_principal_lieu_dit'] : "";
            $demandeur_valeur['localite'] = (isset($request_data['petitionnaire_principal_localite']) === true) ? $request_data['petitionnaire_principal_localite'] : "";
            $demandeur_valeur['code_postal'] = (isset($request_data['petitionnaire_principal_code_postal']) === true) ? $request_data['petitionnaire_principal_code_postal'] : "";
            $demandeur_valeur['bp'] = (isset($request_data['petitionnaire_principal_bp']) === true) ? $request_data['petitionnaire_principal_bp'] : "";
            $demandeur_valeur['cedex'] = (isset($request_data['petitionnaire_principal_cedex']) === true) ? $request_data['petitionnaire_principal_cedex'] : "";
            $demandeur_valeur['pays'] = (isset($request_data['petitionnaire_principal_pays']) === true) ? $request_data['petitionnaire_principal_pays'] : "";
            $demandeur_type = "petitionnaire_principal";
            $demandeur_id = $this->creation_demandeur($demandeur_type, $demandeur_valeur);
            $_POST[$demandeur_type][] = $demandeur_id;
            if ($demandeur_id === false) {
                $this->setMessage(_("Erreur de demandeur: ") . $demandeur_type . ": " . $this->getMessage());
                return $this->BAD_DATA;
            }

            // Permet d'ajouter le délégataire qui dans le cas des DIA est le
            // notaire
            $demandeur_valeur = array();
            $demandeur_id = false;
            $demandeur_type = null;
            $demandeur_valeur['particulier_civilite'] = (isset($request_data['delegataire_particulier_civilite']) === true) ? $request_data['delegataire_particulier_civilite'] : "";
            $demandeur_valeur['particulier_nom'] = (isset($request_data['delegataire_particulier_nom']) === true) ? $request_data['delegataire_particulier_nom'] : "";
            $demandeur_valeur['particulier_prenom'] = (isset($request_data['delegataire_particulier_prenom']) === true) ? $request_data['delegataire_particulier_prenom'] : "";
            $demandeur_valeur['particulier_date_naissance'] = (isset($request_data['delegataire_particulier_date_naissance']) === true) ? $request_data['delegataire_particulier_date_naissance'] : "";
            $demandeur_valeur['particulier_commune_naissance'] = (isset($request_data['delegataire_particulier_commune_naissance']) === true) ? $request_data['delegataire_particulier_commune_naissance'] : "";
            $demandeur_valeur['particulier_departement_naissance'] = (isset($request_data['delegataire_particulier_departement_naissance']) === true) ? $request_data['delegataire_particulier_departement_naissance'] : "";
            $demandeur_valeur['om_collectivite'] = (isset($request_data['om_collectivite']) === true) ? $request_data['om_collectivite'] : "";
            $demandeur_valeur['numero'] = (isset($request_data['delegataire_numero']) === true) ? $request_data['delegataire_numero'] : "";
            $demandeur_valeur['voie'] = (isset($request_data['delegataire_voie']) === true) ? $request_data['delegataire_voie'] : "";
            $demandeur_valeur['complement'] = (isset($request_data['delegataire_complement']) === true) ? $request_data['delegataire_complement'] : "";
            $demandeur_valeur['lieu_dit'] = (isset($request_data['delegataire_lieu_dit']) === true) ? $request_data['delegataire_lieu_dit'] : "";
            $demandeur_valeur['localite'] = (isset($request_data['delegataire_localite']) === true) ? $request_data['delegataire_localite'] : "";
            $demandeur_valeur['code_postal'] = (isset($request_data['delegataire_code_postal']) === true) ? $request_data['delegataire_code_postal'] : "";
            $demandeur_valeur['bp'] = (isset($request_data['delegataire_bp']) === true) ? $request_data['delegataire_bp'] : "";
            $demandeur_valeur['cedex'] = (isset($request_data['delegataire_cedex']) === true) ? $request_data['delegataire_cedex'] : "";
            $demandeur_valeur['pays'] = (isset($request_data['delegataire_pays']) === true) ? $request_data['delegataire_pays'] : "";
            //
            if ($demandeur_valeur['particulier_nom'] !== '') {
                $demandeur_type = "delegataire";
                $demandeur_id = $this->creation_demandeur($demandeur_type, $demandeur_valeur);
                $_POST[$demandeur_type][] = $demandeur_id;
                if ($demandeur_id === false) {
                    $this->setMessage(_("Erreur de demandeur: ") . $demandeur_type . ": " . $this->getMessage());
                    return $this->BAD_DATA;
                }
            }

        }

        // Retraitement commun des données de la demande
        $demande_values = $this->prepare_demande_data($request_data, $demande_values);
        if ($demande_values === false) {
            $this->setMessage(_("Erreur lors de la création de la demande.") . " " . $this->getMessage());
            return $this->BAD_DATA;
        }

        $demande = new demande("]", $this->db, DEBUG);

        // Prise en compte des faux POST
        $demande->f->set_submitted_value();
        $demande->getPostedValues();

        if ($demande->ajouter($demande_values, $this->db, DEBUG) === false) {
            $this->setMessage(_("Erreur lors de la création de la demande."));
            return false;
        }

        $dossier_instruction_id = $demande->valF['dossier_instruction'];
        if ($dossier_instruction_id === false) {
            $this->setMessage(_("Erreur lors de la création de la demande.") . " " . $this->getMessage());
            return $this->BAD_DATA;
        }

        // $match = preg_match("|^([A-Z]{2,3})\s{0,1}(\d{6})\s{0,1}(\d{2})\s{0,1}([[:alnum:]]{5}[A-Z]{0,5}\d{0,2})$|",
        //     $dossier_instruction_id, $return);
        // if ($match != 1) {
        //     $this->setMessage("Erreur lors de la création de la demande. Le format du numéro de dossier n'est pas correct." . $dossier_libelle);
        //     return $this->BAD_DATA;
        // }
        // $dossier_libelle = $return[1] . " " . $return[2] . " " .$return[3] . " " . $return[4];
        // $result = array(
        //     "dossier" => $dossier_libelle,
        // );

        // Retourne le numéro du DI sans les "espaces"
        $result = array(
            "dossier" => $dossier_instruction_id,
        );
        $this->setMessage($result);
        return $this->OK;
    }

    /**
     * Cette méthode complète et reformate les données envoyées en paramétre
     * au web service, seulement dans le cas de la création d'une nouvelle
     * demande, puis fait appel à la méthode générique de création de demande.
     *
     * @param array $request_data Les données brutes de la demande sous forme
     * de tableau associatif.
     * @return array Les données de la demande reformatées et complétées sous
     * forme de tableau associatif.
     */
    private function prepare_new_demande_data($request_data) {

        $demande_values = array();
        $demande = new demande("]", $this->db, DEBUG);

        foreach($demande->champs as $value) {
            $demande_values[$value] = null;
        }
        foreach ($demande->champs as $value) {
            if (array_key_exists($value, $request_data) === true) {
                $demande_values[$value] = $request_data[$value];
            }
        }

        $demande_values['dossier_autorisation_type_detaille']
            = $this->get_dossier_autorisation_type_detaille($request_data["dossier_autorisation_type_detaille"]);
        if ($demande_values['dossier_autorisation_type_detaille'] === false) {
            return false;
        }

        //
        return $demande_values;
    }

    /**
     * Cette méthode complète et reformate les données envoyées en paramétre
     * au web service, seulement dans le cas de la création d'une demande sur
     * existant.
     * 
     * @param array $request_data Les données brutes de la demande sous forme
     * de tableau associatif.
     * @return array Les données de la demande reformatées et complétées sous
     * forme de tableau associatif.
     */
    private function prepare_demande_existant_data($request_data) {
        $demande_values = array();
        $demande = new demande("]", $this->db, DEBUG);

        foreach($demande->champs as $value) {
            $demande_values[$value] = null;
        }

        $dossier_existant_id = str_replace(" ", "", $request_data["dossier_instruction"]);
        $dossier_existant_values = $this->get_values_dossier_existant($dossier_existant_id);
        if ($dossier_existant_values === false) {
            return false;
        }

        foreach ($dossier_existant_values as $colonne => $valeur) {
            $demande_values[$colonne] = $valeur;
        }

        foreach ($demande->champs as $value) {
            if (array_key_exists($value, $request_data) === true) {
                $demande_values[$value] = $request_data[$value];
            }
        }

        $demande_values['dossier_autorisation_type_detaille']
            = $this->get_dossier_autorisation_type_depuis_dossier($dossier_existant_id);
        if ($demande_values['dossier_autorisation_type_detaille'] === false) {
            return false;
        }

        $sql = 'SELECT
            demandeur.demandeur,
            lien_dossier_demandeur.petitionnaire_principal,
            demandeur.type_demandeur
        FROM '.DB_PREFIXE.'lien_dossier_demandeur
            LEFT JOIN '.DB_PREFIXE.'demandeur
            ON lien_dossier_demandeur.demandeur = demandeur.demandeur
        WHERE lien_dossier_demandeur.dossier = \'' . $this->f->db->escapeSimple($dossier_existant_id) . '\'';

        $res = $this->f->db->query($sql);
        $this->f->addToLog(__METHOD__."() : db->query(\"".$sql."\")", VERBOSE_MODE);

        $this->f->isDatabaseError($res);
        while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
            if ($row == 't') {
                $row["type_demandeur"] .= "_principal";
            }
            if (array_key_exists($row["type_demandeur"], $_POST) === false) {
                $_POST[$row["type_demandeur"]] = array();
            }
            $_POST[$row["type_demandeur"]][] = $row['demandeur'];
        }
        $_POST["idx_dossier"] = $dossier_existant_id;
        $demande_values["dossier_instruction"] = $dossier_existant_id;

        //
        return $demande_values;
    }


    /**
     * Cette méthode complète et reformate les paramètres de la nouvelle demande
     * envoyés au web service. Ces traitements sont communs aux nouvelles
     * demandes et aux demandes sur existant.
     *
     * @param array $request_data Les données brutes de la demande sous forme
     * de tableau associatif.
     * @param array $demande_values Les champs et valeurs de l'objet demande
     * @return array Les données de la demande reformatées et complétées sous
     * forme de tableau associatif.
     */
    private function prepare_demande_data($request_data, $demande_values) {

        // // Si les références cadastrales sont récupérées des paramètres passés
        // // en JSON, on les reformate
        // // Si elles sont récupérées d'un dossier existant, on les garde telles
        // // quelles
        // if (array_key_exists("terrain_references_cadastrales", $request_data)
        //     && $demande_values["terrain_references_cadastrales"] !== null) {
        //     //
        //     $demande_values['terrain_references_cadastrales'] = "";
        //     foreach ($request_data["terrain_references_cadastrales"] as $value) {
        //         $demande_values['terrain_references_cadastrales'] .= $value;
        //     }
        //     $demande_values['terrain_references_cadastrales'] = strtoupper($demande_values['terrain_references_cadastrales']) . ";";
        // }

        // Récupère seulement une référence cadastrale
        if (array_key_exists("terrain_references_cadastrales", $request_data)) {
            $demande_values['terrain_references_cadastrales'] = strtoupper($request_data['terrain_references_cadastrales']) . ";";
        }

        if (array_key_exists("date_demande", $request_data)) {
            $demande_values['date_demande'] = $request_data["date_demande"];
        }
        else {
            $demande_values['date_demande'] = (new DateTime())->format('d/m/Y');
        }

        if (isset($request_data["dossier_instruction"]) === true
            && array_key_exists("om_collectivite", $request_data)) {
            $demande_values['om_collectivite'] = $this->get_collectivite($request_data["om_collectivite"]);
        }
        elseif (array_key_exists("om_collectivite", $request_data)) {
            $demande_values['om_collectivite'] = $this->get_collectivite($demande_values["om_collectivite"]);
        }
        if ($demande_values['om_collectivite'] === false) {
            return false;
        }


        $demande_values['demande_type'] = $this->get_demande_type($demande_values["demande_type"], $demande_values['dossier_autorisation_type_detaille']);
        if ($demande_values['demande_type'] === false) {
            return false;
        }

        if (array_key_exists("autorisation_contestee", $request_data) === true) {
            $demande_values["autorisation_contestee"] = str_replace(" ", "", $demande_values["autorisation_contestee"]);
            $demande_values = $this->getAutorisationContestee($demande_values);
            if ($demande_values === false) {
                return false;
            }
        }

        //
        return $demande_values;
    }

    /**
     * Cette methode prend un dossier d'instruction et retourne le type
     * de dossier d'autorisation détaillé.
     *
     * @param string $dossier_instruction_id Le numéro de dossier d'instruction
     * @return int l'identifiant du type de DA detaillé
     */
    private function get_dossier_autorisation_type_depuis_dossier($dossier_instruction_id) {
        $sql = "SELECT demande.dossier_autorisation_type_detaille FROM ".DB_PREFIXE."demande
            WHERE demande.dossier_instruction = '" . $this->f->db->escapeSimple($dossier_instruction_id) . "'";
        $type_id = $this->f->db->getOne($sql);
        $this->f->addToLog(__METHOD__."() : db->getOne(\"".$sql."\")", VERBOSE_MODE);

        if ($this->f->isDatabaseError($type_id) === true) {
            $this->setMessage(_("Erreur de base de données."));
            return false;
        } elseif ($type_id == null) {
            $this->setMessage(_("Le dossier passé en paramètre n'existe pas."));
            return false;
        }
        return $type_id;
    }


    /**
     * Cette methode prend les valeurs du dossier et le complete avec
     * les données du dossier contesté
     *
     * @param array $demande_values Les champs remplis du dossier
     * @return array Les valeurs de la demande complétées
     */
    private function getAutorisationContestee($demande_values) {

        $autorisation_contestee_values = $this->get_values_dossier_existant($demande_values["autorisation_contestee"]);
        if ($autorisation_contestee_values === false) {
            return false;
        }

        foreach ($autorisation_contestee_values as $colonne => $valeur) {
            if ($colonne !== "dossier_autorisation" && $colonne !== "om_collectivite") {
                $demande_values[$colonne] = $valeur;
            }
        }

        $sql = "SELECT
            demandeur.demandeur,
            demandeur.type_demandeur,
            lien_dossier_demandeur.petitionnaire_principal
        FROM ".DB_PREFIXE."lien_dossier_demandeur
        JOIN ".DB_PREFIXE."demandeur 
        ON demandeur.demandeur=lien_dossier_demandeur.demandeur 
        WHERE lien_dossier_demandeur.dossier = '"
        . $this->f->db->escapeSimple($demande_values["autorisation_contestee"]) . "'";

        $res = $this->f->db->query($sql);
        $this->f->addToLog(__METHOD__."() : db->query(\"".$sql."\")", VERBOSE_MODE);
        if ($this->f->isDatabaseError($res, true) === true) {
            $this->setMessage(_("Erreur de base de données."));
            return false;
        }

        $valIdDemandeur = array();
        while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
            $type = $row['type_demandeur'];
            if ($row['petitionnaire_principal'] == 't') {
                $type .= "_principal";
            }
            if (array_key_exists($type, $valIdDemandeur) === false) {
                $valIdDemandeur[$type] = array();
            }
            $valIdDemandeur[$type][] = $row['demandeur'];
        }
        
        foreach ($valIdDemandeur as $type => $demandeur_type_list) {
            foreach ($demandeur_type_list as $key => $demandeur_id) {
                $new_demandeur_id = $this->duplicate_demandeur($demandeur_id);
                if ($new_demandeur_id === false) {
                    return false;
                }
                if (array_key_exists($type, $_POST) === false) {
                    $_POST[$type] = array();
                }
                $_POST[$type][] = $new_demandeur_id;
            }
        }
        return ($demande_values);
    }

    /**
     * Permet de dupliquer le demandeur dont l'identifiant est passé en
     * paramètre.
     * 
     * @param integer $idx Identifiant du demandeur à dupliquer.
     * 
     * @return integer Identifiant du demandeur dupliqué.   
     */
    private function duplicate_demandeur($idx) {
        require_once '../obj/demandeur.class.php';
        $demandeur = new demandeur($idx);
        $demandeur->setValFFromVal();
        $valF = $demandeur->valF;
        $valF['demandeur'] = '';
        $valF['frequent'] = 'f';
        if ($demandeur->ajouter($valF) === true) {
            return $demandeur->valF[$demandeur->clePrimaire];
        }
        return false;
    }

    /**
     * Cette méthode permet de récupérer les données d'un dossier instruction
     * existant, soit dans le contexte de création de dossier sur existant, soit
     * dans le cas d'une autorisation contestée.
     * 
     * @param string $dossier_instruction_id Identifiant du dossier d'instruction.
     * @return int Tableau associatif contenant le nom des champs du dossier et
     * leur valeur.
     */
    private function get_values_dossier_existant($dossier_instruction_id) {

        $dossier_instruction_id = str_replace(" ", "", $dossier_instruction_id);

        $sql = "SELECT
            dossier.dossier_autorisation,
            dossier.om_collectivite,
            dossier.terrain_references_cadastrales,
            dossier.terrain_adresse_voie_numero,
            dossier.terrain_adresse_voie,
            dossier.terrain_superficie,
            dossier.terrain_adresse_lieu_dit,
            dossier.terrain_adresse_localite,
            dossier.terrain_adresse_code_postal,
            dossier.terrain_adresse_bp,
            dossier.terrain_adresse_cedex
        FROM ".DB_PREFIXE."dossier
        WHERE dossier.dossier = '" . $this->f->db->escapeSimple($dossier_instruction_id) . "'";
        
        $res_dossier_instruction_values = $this->f->db->query($sql);
        $this->f->addToLog(__METHOD__."() : db->query(\"".$sql."\")", VERBOSE_MODE);

        if ($this->f->isDatabaseError($res_dossier_instruction_values, true) === true) {
            $this->setMessage(_("Erreur de base de données."));
            return false;
        }
        $raw_dossier_instruction_values = $res_dossier_instruction_values->fetchRow(DB_FETCHMODE_ASSOC);

        if ($raw_dossier_instruction_values === null) {
            $this->setMessage(_("Le dossier passé en paramètre n'existe pas."));
            return false;
        }

        foreach ($raw_dossier_instruction_values as $colonne => $valeur) {
            $dossier_instruction_values[$colonne] = $valeur;
        }
        return $dossier_instruction_values;
    }

    /**
     * Cette methode prend le type de demandeur et ces valeurs pour le créer
     * et renvoit l'identifiant du demandeur créer ou false
     *
     * @param string $demandeur_type Le type de demandeur.
     * @param array $demandeur_valeur Les champs renseignés du demandeur.
     * @return int L'identifiant du demandeur.
     */
    private function creation_demandeur($demandeur_type, $demandeur_valeur) {
        $demandeur = new demandeur("]", $this->db, DEBUG);
        $valAuto = array();

        foreach($demandeur->champs as $value) {
            $valAuto[$value] = null;
        }
        foreach ($demandeur_valeur as $colonne => $valeur) {
            $valAuto[$colonne] = $valeur;
        }
        if (array_key_exists("particulier_civilite", $demandeur_valeur) === true && $demandeur_valeur['particulier_civilite'] !== '') {
            $valAuto['particulier_civilite'] = $this->get_civilite($demandeur_valeur['particulier_civilite']);
            if ($valAuto['particulier_civilite'] === false) {
                return false;
            }
        }
        if (array_key_exists("personne_morale_civilite", $demandeur_valeur) === true) {
            $valAuto['personne_morale_civilite'] = $this->get_civilite($demandeur_valeur['personne_morale_civilite']);
            if ($valAuto['personne_morale_civilite'] === false) {
                return false;
            }
        }
        $valAuto['om_collectivite'] = $this->get_collectivite($demandeur_valeur['om_collectivite']);
        if ($valAuto['om_collectivite'] === false) {
            return false;
        }

        if (array_key_exists("frequent", $demandeur_valeur) === true) {
            $valAuto['frequent'] = true;
            if($demandeur_valeur["frequent"] === "false")
                $valAuto['frequent'] = false;
        }

        if (array_key_exists("qualite", $demandeur_valeur) === true) {
            $valAuto['qualite'] = str_replace(" ", "_", $demandeur_valeur['qualite']);
        }
        else {
            $valAuto['qualite'] = 'particulier';
        }
        $valAuto['type_demandeur'] = str_replace("_principal", "", $demandeur_type);

        if ($demandeur->ajouter($valAuto, $this->db, DEBUG) === false) {
            $this->setMessage(_("Erreur lors de l'ajout du demandeur."));
            return false;
        }
        return $demandeur->valF['demandeur'];
    }

    /**
     * Cette méthode prend le libellé de la collectivité et la transforme en
     * son identifiant en la trouvant dans la base de données et en la
     * sauvegardant pour réutilisation (ex: la même collectivité pour
     * le pétitionnaire que la demande)
     *
     * @param string $collectivite_libelle Libellé de la collectivité.
     * @return int L'identifiant de la collectivité.
     */
    private function get_collectivite($collectivite_libelle) {
        if (array_key_exists($collectivite_libelle, $this->collectivite) === false) {
            $sql = "SELECT om_collectivite FROM ".DB_PREFIXE."om_collectivite
                WHERE om_collectivite.libelle = '" . $this->f->db->escapeSimple($collectivite_libelle) . "'";
            $om_collectivite = $this->db->getOne($sql);
            $this->f->addToLog(__METHOD__."() : db->getOne(\"".$sql."\")", VERBOSE_MODE);

            if ($this->f->isDatabaseError($om_collectivite) === true) {
                $this->setMessage(_("Erreur de base de données."));
                return false;
            } elseif ($om_collectivite === null) {
                $this->setMessage(_("La collectivité passée en paramètre n'existe pas."));
                return false;
            }
            $this->collectivite[$collectivite_libelle] = $om_collectivite;
        }
        return $this->collectivite[$collectivite_libelle];
    }

    /**
     * Cette methode prend libellé de la civilite et la transforme en
     * son identifiant en la trouvant dans la base de données et en la
     * sauvegardant pour réutilisation (ex: la même collectivité pour
     * le pétitionnaire que la demande)
     *
     * @param string $civilite_libelle Libellé de la civilité.
     * @return int L'identifiant de la civilité.
     */
    private function get_civilite($civilite_libelle) {
        $sql = "SELECT civilite FROM ".DB_PREFIXE."civilite
            WHERE civilite.libelle = '" . $this->f->db->escapeSimple($civilite_libelle) . "'";
        $civilite = $this->db->getOne($sql);
        $this->f->addToLog(__METHOD__."() : db->getOne(\"".$sql."\")", VERBOSE_MODE);

        if ($this->f->isDatabaseError($civilite) === true) {
            $this->setMessage(_("Erreur de base de données."));
            return false;
        } elseif ($civilite === null) {
            $this->setMessage(_("La civilité passée en paramètre n'existe pas."));
            return false;
        }
        return $civilite;
    }

    /**
     * Cette methode prend en paramètre le libellé du type de demande et le
     * transforme en son identifiant en la trouvant dans la base de données en
     * vérifiant le type détaillé.
     * @param string $demande_type_libelle nom de la demande type.
     * @param string $datd_id Identifiant du type de dossier d'autorisation détaillé.
     * @return int Le résultat du traitement
     */
    private function get_demande_type($demande_type_libelle, $datd_id) {
        $sql = "SELECT demande_type FROM ".DB_PREFIXE."demande_type
            WHERE demande_type.libelle = '" . $this->f->db->escapeSimple($demande_type_libelle) . "'
            AND demande_type.dossier_autorisation_type_detaille = " . $this->f->db->escapeSimple($datd_id);
        $demande_type = $this->f->db->getOne($sql);
        $this->f->addToLog(__METHOD__."() : db->getOne(\"".$sql."\")", VERBOSE_MODE);

        if ($this->f->isDatabaseError($demande_type) === true) {
            $this->setMessage(_("Erreur de base de données."));
            return false;
        } elseif ($demande_type === null) {
            $this->setMessage(_("Le type de demande passé en paramètre n'existe pas."));
            return false;
        }
        return $demande_type;

    }

    /**
     * Cette methode prend le nom du dossier autorisation type detaillé
     *  et la transforme en son identifiant en la trouvant dans la base
     * de données
     *
     * @param string $datd_libelle Libellé du type de dossier d'autorisation detaillé
     * @return int Le résultat du traitement
     */
    private function get_dossier_autorisation_type_detaille($datd_libelle) {
        $sql = "SELECT dossier_autorisation_type_detaille FROM ".DB_PREFIXE."dossier_autorisation_type_detaille
            WHERE dossier_autorisation_type_detaille.libelle = '" . $this->f->db->escapeSimple($datd_libelle) . "'";
        $datd = $this->f->db->getOne($sql);
        $this->f->addToLog(__METHOD__."() : db->getOne(\"".$sql."\")", VERBOSE_MODE);

        if ($this->f->isDatabaseError($datd) === true) {
            $this->setMessage(_("Erreur de base de données."));
            return false;            
        } elseif ($datd === null) {
            $this->setMessage(_("Le type de dossier d'autorisation détaillé passé en paramètre n'existe pas."));
            return false;
        }
        return $datd;
    }


    /**
     * Récupère le récépissé (première instruction) et la dernière décision
     * (RENONCIATION A PREEMPTER) du dossier d'instruction.
     *
     * @param string $di Identifiant du dossier d'instruction.
     *
     * @return array Tableau des liens vers le recepissé et la décision.
     */
    public function get_recepisse_and_decision($di) {
        //
        $template_link = "%s/web/file.php/?uid=%s";
        //
        $base_url = $this->get_base_url();

        // Récupère l'uid du fichier du récépissé
        $sql = sprintf("SELECT om_fichier_instruction
                FROM ".DB_PREFIXE."instruction
                LEFT JOIN ".DB_PREFIXE."demande ON demande.instruction_recepisse = instruction.instruction
                WHERE demande.dossier_instruction = '%s'
                AND demande.demande_type = 150", $di);
        $recepisse = $this->f->db->getOne($sql);
        $this->f->addToLog(__METHOD__."() : db->getOne(\"".$sql."\")", VERBOSE_MODE);
        $this->f->isDatabaseError($recepisse);
        //
        $link_recepisse = "";
        //
        if ($recepisse !== '' && $recepisse !== null) {
            //
            // $link_recepisse = sprintf($template_link, $base_url, $recepisse);
            $link_recepisse = $recepisse;
        }

        // Récupère l'uid du fichier de la dernière décision de renonciation à
        // préempter
        $sql = sprintf("SELECT om_fichier_instruction
                FROM ".DB_PREFIXE."instruction
                WHERE dossier = '%s'
                AND evenement = 552
                ORDER BY date_evenement DESC
                LIMIT 1", $di);
        $decision = $this->f->db->getOne($sql);
        $this->f->addToLog(__METHOD__."() : db->getOne(\"".$sql."\")", VERBOSE_MODE);
        $this->f->isDatabaseError($decision);
        //
        $link_decision = "";
        //
        if ($decision !== '' && $decision !== null) {
            //
            // $link_decision = sprintf($template_link, $base_url, $decision);
            $link_decision = $decision;
        }

        // Résultat à retourner
        $res = array();
        //
        $res['recepisse'] = $link_recepisse;
        $res['decision'] = $link_decision;
        //
        $this->setMessage($res);
        return $this->OK;
    }


    /**
     * Récupère la base de l'URL.
     *
     * @return string URL.
     */
    function get_base_url() {
        // Récupération du protocole
        $protocol = 'http';
        if(isset($_SERVER['HTTPS'])){
            $protocol = ($_SERVER['HTTPS'] && $_SERVER['HTTPS'] != "off") ? "https" : "http";
        }
        // Récupération du domaine
        $domain = $_SERVER['HTTP_HOST'];
        // Récupération du port
        $port = $_SERVER['SERVER_PORT'];
        $disp_port = ($protocol == 'http' && $port == 80 || $protocol == 'https' && $port == 443) ? '' : ":$port";
        // Construction du chemin restant
        $base_url = str_replace('services', '', rtrim(dirname($_SERVER['PHP_SELF']), '/\\'));
        $base_url = str_replace('dia', '', rtrim(dirname($base_url), '/\\'));
        $base_url = str_replace('rest_entry.php', '', rtrim(dirname($base_url), '/\\'));
        //
        return $protocol."://".$domain.$disp_port.$base_url;
    }


}

?>