<?php
/**
 * DBFORM - 'instruction_notification_manuelle' - Surcharge instruction.
 *
 * @package openads
 * @version SVN : $Id$
 */

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

//
class instruction_notification_manuelle extends instruction {

    /**
     *
     */
    protected $_absolute_class_name = "instruction_notification_manuelle";

    /**
     * Définition des actions disponibles sur la classe.
     *
     * @return void
     */
    function init_class_actions() {
        parent::init_class_actions();

        // ACTION - 411 - view_notification_manuelle
        $this->class_actions[411] = array(
            "identifier" => "notification_manuelle",
            "view" => "view_notification_manuelle",
            "permission_suffix" => "modifier",
        );
    }

    /**
     * VIEW - view_notification_manuelle.
     *
     * Ouvre le sous-formulaire en ajaxIt dans un overlay.
     * Cette action est bindée pour utiliser la fonction popUpIt.
     *
     * @return void
     */
    function view_notification_manuelle() {
        // Vérification de l'accessibilité sur l'élément
        $this->checkAccessibility();
        // Préparation du type de message de retour
        $message_class = "valid";
        // Non affichage du fil d'ariane
        $this->getSubFormTitle('');

        // Vérification que le paramétrage nécessaire pour l'envoi des notifications existe
        $dossier = $this->getVal('dossier');
        $collectivite_di = $this->get_dossier_instruction_om_collectivite($dossier);
        
        // Récupération de la catégorie et notification des demandeurs choisis
        $categorie = $this->f->get_param_option_notification($collectivite_di);
        // Récupération de la liste des demandeurs notifiables
        if ($categorie == null || $categorie == '' || $categorie == 'portal') {
            // Pour une notification par portail récupère uniquement le pétitionnaire principal
            $demandeurs = $this->get_demandeurs_notifiable($this->getVal('dossier'), true);
        } else {
            $demandeurs = $this->get_demandeurs_notifiable();
        }

        // TODO : a améliorer
        // Récupération de l'id du pétitionnaire principal
        $sql = sprintf(
            'SELECT
                demandeur
            FROM
                %1$slien_demande_demandeur
                INNER JOIN %1$sdemande ON lien_demande_demandeur.demande = demande.demande
            WHERE
                demande.dossier_instruction = \'%2$s\' AND
                petitionnaire_principal = TRUE',
            DB_PREFIXE,
            $this->getVal('dossier')
        );
        $idPetitioPrinc = $this->f->db->getOne($sql);
        $this->f->addToLog(__METHOD__."(): db->getOne(\"".$sql."\")", VERBOSE_MODE);
        if ($this->f->isDatabaseError($idPetitioPrinc, true)){
            $this->f->addToLog(__METHOD__."(): ERROR db->getOne(\"".$sql."\")", DEBUG_MODE);
            $idPetitioPrinc = '';
        }


        //
        // Traitement des données du formulaire
        //
        // Si des données ont été envoyées par le formulaire
        $postValues = $this->f->get_submitted_post_value();
        if ($postValues != null && is_array($postValues) && $postValues != array()) {
            // Récupération de la liste des demandeurs à notifier
            $nbDemChoisis = 0;
            // Dans le cas d'une notification via le portail web seul le pétitionnaire
            // principale est notifiable. Dans le formulaire la liste des pétitionnaire
            // notifiable ne sera pas affiché.
            // Pour pouvoir réutiliser le traitement des autres modes de notification
            // l'id du demandeur est récupéré et ajouté aux valeurs récupéré du POST
            // en faisant comme si il s'agissait d'une case cochée dans le formulaire.
            if ($categorie == null || $categorie == '' || $categorie === 'portal') {
                $idPetiPrinc = array_keys($demandeurs);
                $postValues[$idPetiPrinc[0]] = 'Oui';
            }
            // Création d'une notification et d'une tâche pour chaque demandeur à notifier
            $idInstructionAnnexe = null;
            // Récupération de l'id de l'instruction du doc choisi comme annexe
            if (array_key_exists('instruction_signee_finalisee', $postValues)) {
                $idInstructionAnnexe = $postValues['instruction_signee_finalisee'];
            }
            foreach ($postValues as $idChamps => $valeur) {
                if ($valeur == 'Oui' && is_numeric($idChamps)) {
                    $idDemandeur = $idChamps;
                    $nbDemChoisis++;
                    // Ajout de la notif et récupération de son id
                    $idNotif = $this->ajouter_notification(
                        $this->getVal($this->clePrimaire),
                        false,
                        $this->f->get_connected_user_login_name(),
                        $demandeurs[$idDemandeur],
                        $idInstructionAnnexe
                    );
                    if ($idNotif === false) {
                            $message_class = "error";
                            $message = __("Erreur lors de la génération de la notification au(x) pétitionnaire(s).");
                            $this->f->displayMessage($message_class, $message);
                            // quitte la boucle si l'ajout de la notification échoue
                            break;
                    }
                    // Création de la tache en lui donnant l'id de la notification
                    $notification_by_task = $this->notification_by_task(
                        $idNotif,
                        $this->getVal('dossier'),
                        $categorie
                    );
                    if ($notification_by_task === false) {
                        $message_class = "error";
                        $message = __("Erreur lors de la génération de la notification au(x) pétitionnaire(s).").'<br/>';
                        $this->f->displayMessage($message_class, $message);
                        // quitte la boucle si l'ajout de la tache de notification échoue
                        break;
                    }
                }
            }
            if ($nbDemChoisis === 0) {
                $message = __("Aucun pétitionnaire n'a été sélectionné.").'<br/>';
                $this->f->displayMessage($message_class, $message);
            } elseif ($message_class === 'valid') {
                // Message de valisation si il n'y a pas eu d'erreur au cours du traitement
                $message = sprintf('%s<br/>%s', __("La notification a été générée."), __("Le suivi de la notification est disponible depuis l'instruction."));
                $this->f->displayMessage($message_class, $message);
            }
        }

        //
        // Affichage du formulaire
        //
        // Récupération du paramétrage d'affichage de la vue
        $evenement = $this->get_inst_evenement($this->getVal('evenement'));
        $moyenNotification = $this->f->get_param_option_notification($collectivite_di);
        $selectionPetitio = $moyenNotification != null && $moyenNotification != 'portal' ?
            true : false;
        $typeNotif = $evenement->getVal('notification');
        $selectAnnexe = $typeNotif == 'notification_manuelle_annexe' || $typeNotif == 'notification_manuelle_annexe_signature_requise' ?
            true : false;

        $champs = array();
        // Préparation des champs de sélection des demandeurs
        if ($selectionPetitio === true) {
            if ($demandeurs === array()) {
                // Affiche un message d'erreur si aucun demandeur ne peut être notifié
                $message_class = "error";
                $message = _("Aucun demandeur notifiable");
                $this->f->displayMessage($message_class, $message);
                return;
            }
            // Préparation de l'instanciation de l'objet formulaire avec 1 champs par demandeur
            $champs = array_keys($demandeurs);
        }

        // Préparation du champs de sélection de l'annexe
        if ($selectAnnexe === true) {
            // Préparation du champs de select de l'annexe
            $champs[] = "instruction_signee_finalisee";
            // Recupération du contenu du select. Seul les instruction, du dossier, ayant une édition
            // finalisé et signé doivent pouvoir être sélectionnées.
            $sql = sprintf(
                'SELECT
                    evenement.libelle,
                    instruction.instruction
                FROM
                    %1$sevenement
                    INNER JOIN %1$sinstruction ON instruction.evenement=evenement.evenement 
                WHERE
                    instruction.date_retour_signature is not null
                    and om_final_instruction=true
                    and instruction.instruction != %2$s
                    and instruction.dossier=\'%3$s\'',
                DB_PREFIXE,
                $this->getVal($this->clePrimaire),
                $this->getVal("dossier")
            );
            
            $res = $this->f->db->query($sql);
            $this->addToLog(__METHOD__." : db->query(\"".$sql."\");", VERBOSE_MODE);
            $this->f->isDatabaseError($res);

            // Remplissage du tableau du select 
            $contenu = array(
                0 => array(""),
                1 => array(_('choisir')." "._('evenement'))
            );
            while ($row=& $res->fetchRow(DB_FETCHMODE_ASSOC)) {
                $contenu[0][] = $row['instruction'];
                $contenu[1][] = $row['libelle'];
            }
        }

        // Affichage du formulaire, si il y a des élements à afficher
        if ($champs != array()) {
            // Instanciation du formulaire avec les champs voulus
            $form = $this->f->get_inst__om_formulaire(array(
                "validation" => 0,
                "maj" => $this->getParameter("maj"),
                "champs" => $champs
            ));
            $listIdDemandeurs = array_keys($demandeurs);
            $premierChamps = isset($listIdDemandeurs[0]) ? $listIdDemandeurs[0] : null;
            $dernierChamps = null;

            // Paramétrage des champs correspondant aux différents demandeurs
            if ($selectionPetitio === true) {
                foreach ($listIdDemandeurs as $idDemandeur) {
                    $dernierChamps = $idDemandeur;
                    // Paramétrage des champs du formulaire
                    $form->setType($idDemandeur, 'checkbox');
                    $form->setTaille($idDemandeur, 1);
                    $form->setMax($idDemandeur, 1);
                    $form->setVal($idDemandeur, 'f');
    
                    // Récupération des informations du demandeur
                    $demandeur = $this->f->get_inst__om_dbform(array(
                        "obj" => 'demandeur',
                        "idx" => $idDemandeur,
                    ));
                    // TODO : optimiser la récuépration du nom du demandeur ou écrire une méthode servant
                    // à la récupérer
                    // Comme il ne peut y avoir de nom que pour une personne morale ou un particulier
                    // en utilisant tous les champs et en faisant un trim l'intitulé peut être récupéré
                    $intituleDem =
                        $demandeur->getVal('particulier_nom').
                        ' '.
                        $demandeur->getVal('particulier_prenom').
                        ' '.
                        $demandeur->getVal('personne_morale_denomination').
                        ' '.
                        $demandeur->getVal('personne_morale_raison_sociale');

                    if ($demandeur->getVal('personne_morale_nom') != '' &&
                        $demandeur->getVal('personne_morale_prenom') != '') {
                        $intituleDem .= sprintf(
                            ' représenté par %1$s %2$s',
                            $demandeur->getVal('personne_morale_nom'),
                            $demandeur->getVal('personne_morale_prenom')
                        );
                    }
                    // Récupération du type de pétitionnaire à partir des infos de la demande
                    $typeDemandeur = $idPetitioPrinc == $demandeur->getVal('demandeur') ?
                        __('pétitionnaire principal') :
                        __($demandeur->getVal('type_demandeur'));

                    $lib = sprintf(
                        '%1$s | %2$s | %3$s',
                        $intituleDem,
                        $demandeur->getVal('courriel'),
                        $typeDemandeur
                    );
                    $form->setLib($idDemandeur, trim($lib));
                }
            }

            // Parmétrage du champs annexe dans le formulaire
            if ($selectAnnexe === true) {
                $form->setType('instruction_signee_finalisee', 'select');
                $form->setLib('instruction_signee_finalisee', 'pièce à joindre');
                $form->setSelect("instruction_signee_finalisee", $contenu);
                $form->setVal("instruction_signee_finalisee", '');
            }

            if ($premierChamps != null) {
                $form->setBloc($premierChamps, 'D', _("Sélection des pétitionnaires à notifier"), "alignFormSpec");
                $form->setBloc($dernierChamps, 'F', "", "alignFormSpec");
            }
            $form->setBloc('instruction_signee_finalisee','D', _("Sélection d'une annexe"), "alignFormSpec");
            $form->setBloc('instruction_signee_finalisee','F', "", "alignFormSpec");

            // Ouverture du formulaire de sélection des demandeurs
            $this->f->layout->display__form_container__begin(array(
                "action" => '',
                "onsubmit" => "affichersform('instruction_notification_manuelle', '".
                    $this->getDataSubmit().
                    "', this); validation_formulaire_notification_manuelle(); return false;",
                "name" => "f2",
            ));
            // Ouverture du conteneur de formulaire
            $form->entete();
            // affichage des champs
            $form->afficher($champs, 0, false, false);
            // Fermeture du conteneur de formulaire
            $form->enpied();
            $this->f->layout->display__form_controls_container__begin(array(
                "controls" => "bottom",
            ));
            // Affichage du bouton valider
            $this->f->layout->display__form_input_submit(array(
                "name" => "submit-directory",
                "value" => __("Valider"),
                "class" => "boutonFormulaire",
            ));
            $this->f->layout->display__form_controls_container__end();
            $this->f->layout->display__form_container__end();
        }
    }
}// fin classe
