trunk/obj/action.class.php

<?php
/**
 * DBFORM - 'action' - Surcharge gen.
 *
 * Ce script permet de définir la classe 'action'.
 *
 * @package openads
 * @version SVN : $Id$
 */

require_once "../gen/obj/action.class.php";

class action extends action_gen {

    // Handler d'un objet de classe dossier
    var $dossier;

    // Liste des regles de dates
    var $date_rules = array(
        'regle_delai',
        'regle_delai_incompletude',
        'regle_date_limite',
        'regle_date_notification_delai',
        'regle_date_complet',
        'regle_date_validite',
        'regle_date_decision',
        'regle_date_chantier',
        'regle_date_achevement',
        'regle_date_conformite',
        'regle_date_rejet',
        'regle_date_dernier_depot',
        'regle_date_limite_incompletude',
        'regle_date_cloture_instruction',
        'regle_date_premiere_visite',
        'regle_date_derniere_visite',
        'regle_date_contradictoire',
        'regle_date_retour_contradictoire',
        'regle_date_ait',
        'regle_date_transmission_parquet',
        'regle_date_affichage',
    );

    const EVENEMENT_FIELDS = array(
        'etat',
        'delai',
        'accord_tacite',
        'avis_decision',
        'delai_notification',
        'date_evenement',
        'autorite_competente',
        'pec_metier',
        'complement_om_html',
        'complement2_om_html',
        'complement3_om_html',
        'complement4_om_html',
    );

    function setValF($val = array()) {
        parent::setValF($val);
        foreach ($this->date_rules as $key => $rule){
            $this->valF[$rule] = $this->f->formatage_regles($this->valF[$rule]);
        }
    }

    function setType(&$form, $maj) {
        parent::setType($form, $maj);
        
        if ($maj == 0 || $maj == 1) {
            $form->setType("regle_donnees_techniques1", "regle_donnees_techniques");
            $form->setType("regle_donnees_techniques2", "regle_donnees_techniques");
            $form->setType("regle_donnees_techniques3", "regle_donnees_techniques");
            $form->setType("regle_donnees_techniques4", "regle_donnees_techniques");
            $form->setType("regle_donnees_techniques5", "regle_donnees_techniques");
            $form->setType("cible_regle_donnees_techniques1", "nodisplay");
            $form->setType("cible_regle_donnees_techniques2", "nodisplay");
            $form->setType("cible_regle_donnees_techniques3", "nodisplay");
            $form->setType("cible_regle_donnees_techniques4", "nodisplay");
            $form->setType("cible_regle_donnees_techniques5", "nodisplay");
        }
        if ($maj == 2 || $maj == 3) {
            $form->setType("regle_donnees_techniques1", "regle_donnees_techniques_static");
            $form->setType("regle_donnees_techniques2", "regle_donnees_techniques_static");
            $form->setType("regle_donnees_techniques3", "regle_donnees_techniques_static");
            $form->setType("regle_donnees_techniques4", "regle_donnees_techniques_static");
            $form->setType("regle_donnees_techniques5", "regle_donnees_techniques_static");
            $form->setType("cible_regle_donnees_techniques1", "nodisplay");
            $form->setType("cible_regle_donnees_techniques2", "nodisplay");
            $form->setType("cible_regle_donnees_techniques3", "nodisplay");
            $form->setType("cible_regle_donnees_techniques4", "nodisplay");
            $form->setType("cible_regle_donnees_techniques5", "nodisplay");
        }
    }
    
    function setLib(&$form, $maj) {
        parent::setLib($form, $maj);
        $form->setLib('regle_etat',__('Règle état'));
        $form->setLib('regle_delai',__('Règle delai (DATE)'));
        $form->setLib('regle_accord_tacite',__('Règle accord tacite (UNIQUE)'));
        $form->setLib('regle_avis',__('Règle avis'));
        $form->setLib('regle_date_limite',__('Règle date limite (DATE)'));
        $form->setLib('regle_date_notification_delai',__('Règle date de délai de notification (DATE)'));
        $form->setLib('regle_date_complet',__('Règle date complet (DATE)'));
        $form->setLib('regle_date_validite',__('Règle date de validite (DATE)'));
        $form->setLib('regle_date_decision',__('Règle date de décision (DATE)'));
        $form->setLib('regle_date_chantier',__('Règle date de chantier (DATE)'));
        $form->setLib('regle_date_achevement',__("Règle date d'achevement (DATE)"));
        $form->setLib('regle_date_conformite',__('Règle date de conformite (DATE)'));
        $form->setLib('regle_date_rejet',__('Règle date rejet (DATE)'));
        $form->setLib('regle_date_dernier_depot',__('règle date de dernier dépot (DATE)'));
        $form->setLib('regle_date_limite_incompletude',__("Règle date limite d'incomplétude (DATE)"));
        $form->setLib('regle_delai_incompletude',__("Règle delai d'incomplétude (DATE)"));
        $form->setLib('regle_autorite_competente',__('Règle autorité compétente (UNIQUE)'));
        $form->setLib('regle_date_cloture_instruction',__("Règle date de clôture de l'instruction (DATE)"));
        $form->setLib('regle_date_premiere_visite',__("Règle date de première visite (DATE)"));
        $form->setLib('regle_date_derniere_visite',__("Règle date de dernière visite (DATE)"));
        $form->setLib('regle_date_contradictoire',__("Règle date de contradictoire (DATE)"));
        $form->setLib('regle_date_retour_contradictoire',__("Règle date de retour de contradictoire (DATE)"));
        $form->setLib('regle_date_ait',__("Règle date AIT (DATE)"));
        $form->setLib('regle_date_transmission_parquet',__("Règle date de transmission au Parquet (DATE)"));

        $form->setLib('regle_donnees_techniques1',__('Règle donnée techniques / CERFA n°1'));
        $form->setLib('regle_donnees_techniques2',__('Règle donnée techniques / CERFA n°2'));
        $form->setLib('regle_donnees_techniques3',__('Règle donnée techniques / CERFA n°3'));
        $form->setLib('regle_donnees_techniques4',__('Règle donnée techniques / CERFA n°4'));
        $form->setLib('regle_donnees_techniques5',__('Règle donnée techniques / CERFA n°5'));

        $form->setLib('cible_regle_donnees_techniques1',__('Champ cible de la règle donnée technique n°1'));
        $form->setLib('cible_regle_donnees_techniques2',__('Champ cible de la règle donnée technique n°2'));
        $form->setLib('cible_regle_donnees_techniques3',__('Champ cible de la règle donnée technique n°3'));
        $form->setLib('cible_regle_donnees_techniques4',__('Champ cible de la règle donnée technique n°4'));
        $form->setLib('cible_regle_donnees_techniques5',__('Champ cible de la règle donnée technique n°5'));

        $form->setLib('regle_dossier_instruction_type',__("Règle type de dossier d'instruction (NUMERIQUE)"));
        $form->setLib('regle_date_affichage',__("Règle date d'affichage (DATE)"));
        $form->setLib('regle_pec_metier',__("Règle prise en compte métier (UNIQUE)"));
        $form->setLib('regle_a_qualifier',__("Règle à qualifier (BOOLEAN)"));
        $form->setLib('regle_incompletude',__("Règle incomplétude (BOOLEAN)"));
        $form->setLib('regle_incomplet_notifie',__("Règle incomplétude notifiée (BOOLEAN)"));
        $form->setLib('regle_etat_pendant_incompletude',__("Règle état du dossier pendant l'incomplétude (UNIQUE)"));
        $form->setLib('regle_evenement_suivant_tacite_incompletude',__("Règle événement suivant tacite de l'événement s'applique lors de
         l'incomplétude notifiée (BOOLEAN)"));
    }

    /**
     * @return void
     */
    function verifier($val = array(), &$dnu1 = null, $dnu2 = null) {
        parent::verifier($val);
        //
        $list_column = array();
        // Mot-clés à rechercher
        $search_field = "regle_";
        // Pour chaque champs du formulaire
        foreach ($this->champs as $champ) {
            // Si le mot-clés est présent dans l'identifiant du champ
            if (strpos($champ, $search_field) !== false) {
                // Ajoute le champ à la liste
                $list_column[] = $champ;
            }
        }

        // 
        $list_fields = array();
        // Pour chaque colonne
        foreach ($list_column as $value) {
            
            // Vérifie que le champs existe dans le formulaire et qu'il n'est 
            // pas vide
            if (isset($this->valF[$value]) 
                && $this->valF[$value] != ''
                && $this->valF[$value] != null) {
                //
                $list_fields[$value] = $this->valF[$value];
            }
        }

        // Si le tableau contenant les champs à tester n'est pas vide
        if (count($list_fields) > 0) {

            //
            foreach ($list_fields as $key => $value) {

                // Vérification de la possibilité des champs de la table dossier
                // correspondants aux règles d'être mis à null
                if($this->valF[$key] == "NULL" || $this->valF[$key] == "null") {
                    //
                    if($this->fieldCanBeNull(substr($key, 6)) === false) {
                        // Affiche l'erreur
                        $this->correct=false;
                        $error_message = __("Le champ %s des dossiers ne peut etre mis a NULL.");
                        $this->addToMessage(sprintf($error_message, "<b>".__(substr($key, 6))."</b>"));

                    }
                }

                // Vérifie que la règle est valide
                $this->rule_is_valid($value, $key);
            }
        }
        
        // Vérification de la présence du couple cible règle pour les DT
        for ($i = 1; $i < 6; $i++) { 
            if ($this->valF["regle_donnees_techniques".$i] === null XOR
                $this->valF["cible_regle_donnees_techniques".$i] === null) {
                
                $this->correct=false;
                $this->addToMessage(
                    sprintf(
                        __("Le champ <b>Règle données techniques / CERFA</b> %s ne peut comporter un champ rempli et un champ vide"),
                        $i
                    )
                );
            }
        }

        
    }

    /**
     * Vérification que les champs ciblés par les règles contenant NULL peuvent
     * l'être.
     * @param  string $field champ impacté par la règle
     * @return boolean       peut être null = true else false
     */
    function fieldCanBeNull($field) {
        // Instantiation de la classe dossier si pas déjà fait
        if(!isset($this->dossier) || empty($this->dossier)) {
            $this->dossier = $this->f->get_inst__om_dbform(array(
                "obj" => "dossier",
                "idx" => "]",
            ));
        }
        // Si le champ passé en param est dans la liste des champs obligatoires
        // de la table dossier return false
        if(array_search($field, $this->dossier->required_field) !== false) {
            return false;
        }
        return true;
    }

    /**
     * Vérifie la validité d'une règle d'action.
     * 
     * @param string $rule      Règle d'action.
     * @param string $rule_name Nom de la règle.
     */
    function rule_is_valid($rule, $rule_name) {    
        // Liste des régles de type 'champ de BDD'
        $cible_donnees_techniques_rules  = array(
            'cible_regle_donnees_techniques1',
            'cible_regle_donnees_techniques2',
            'cible_regle_donnees_techniques3',
            'cible_regle_donnees_techniques4',
            'cible_regle_donnees_techniques5',
        );

        // Liste des régles a Opérateur unique
        $unique_operand_rules = array(
            'regle_autorite_competente',
            'regle_etat',
            'regle_accord_tacite',
            'regle_pec_metier',
            'regle_etat_pendant_incompletude',
        );

        $common_rules = array(
            'regle_etat',
            'regle_accord_tacite',
            'regle_avis',
            'regle_autorite_competente',
            'regle_donnees_techniques1',
            'regle_donnees_techniques2',
            'regle_donnees_techniques3',
            'regle_donnees_techniques4',
            'regle_donnees_techniques5',
            'regle_pec_metier',
            'regle_etat_pendant_incompletude',
        );

        $boolean_rules = array_merge(
            $common_rules,
            array(
                'regle_a_qualifier',
                'regle_incompletude',
                'regle_incomplet_notifie',
                'regle_evenement_suivant_tacite_incompletude',
            )
        );

        $numeric_rules = array_merge(
            $common_rules,
            array(
                'regle_dossier_instruction_type',
            )
        );

        // Si la règle à vérifier concerne les données techniques, il faut
        // récupérer le type du champ des données techniques sélectionné.
        if (in_array($rule_name, $cible_donnees_techniques_rules, true) === true) {
            // Récupération du type de champ de la cible de la règle
            $type = $this->f->get_type_from_db(
                'donnees_techniques',
                $this->valF[$rule_name]
            );
            if (isset($type[$this->valF[$rule_name]]) === false
                || $type[$this->valF[$rule_name]] !== 'text') {
                $this->correct=false;
                $this->addToMessage(
                    sprintf(
                        __('Le champ %s ne peut être que de type texte.'),
                        '<b>'.__($rule_name).'</b>'
                    )
                );
            }
        }

        // Gestion du null
        $is_null_result = $this->f->rule_null_is_valid($rule, $rule_name);
        if ( is_array($is_null_result)  === true ){
            if ( $is_null_result[0] === false ){
                // Affiche l'erreur
                $this->correct=$is_null_result[0];
                $this->addToMessage($is_null_result[1]);
            }
            return null;
        }

        // Supprime tous les espaces de la chaîne de caractère
        $rule = str_replace(' ', '', $rule);
        // Coupe la chaîne au niveau de l'opérateur
        $operands = explode('+', $rule);
        // Nombre d'opérande
        $nb_operands = count($operands);

        // Si c'est une règle spécifique unique
        if (in_array($rule_name, $unique_operand_rules, true) === true) {
            // S'il y à plus d'une opérande
            if ($nb_operands > 1) {
                // Message d'erreur
                $this->correct=false;
                $this->addToMessage(
                    sprintf(__("Le champ %s ne peut pas avoir plus d'un opérande."),
                        '<b>'.__($rule_name).'</b>')
                );
                return null;
            }
        }

        // Pour chaque opérande
        foreach ($operands as $key => $operand) {
            // si on as une chaine +xmois ou +xjour(s) pour une regle de type date
            if (in_array($rule_name, $this->date_rules, true) === true) {
                $is_date_result = $this->f->rule_date_is_valid($operand, $rule_name);
                if ( is_array($is_date_result) === true ){
                    if ( $is_date_result[0] === false ){
                        // Affiche l'erreur
                        $this->correct=$is_date_result[0];
                        $this->addToMessage($is_date_result[1]);
                        return null;
                    }
                    // Supprime l'opérande
                    unset($operands[$key]);
                }
            }

            // Supprime les numériques pour les regles acceptant le numérique
            if (
                in_array($rule_name, $numeric_rules, true) === true
                && is_numeric($operand)
            ) {
                // Supprime l'opérande
                unset($operands[$key]);
            }

            // Supprime également les booléens pour les regles acceptant les booleans
            if (
                in_array($rule_name, $boolean_rules, true) === true
                && ($operand == 'f' || $operand == 't'
                || $operand == 'false' || $operand == 'true')
            ) {
                // Supprime l'opérande
                unset($operands[$key]);
            }
        }

        $rules = array(
            'regle_donnees_techniques1',
            'regle_donnees_techniques2',
            'regle_donnees_techniques3',
            'regle_donnees_techniques4',
            'regle_donnees_techniques5',
            'cible_regle_donnees_techniques1',
            'cible_regle_donnees_techniques2',
            'cible_regle_donnees_techniques3',
            'cible_regle_donnees_techniques4',
            'cible_regle_donnees_techniques5',
        );

        if (in_array($rule_name, $rules, true) === true) {

            // Vérification de l'existance des champs de règle dans les données
            // technique
            $check_field_dt_exist = $this->f->check_field_exist(
                $operands,
                'donnees_techniques'
            );

            $check_field_instr_exist = $this->f->check_field_exist(
                $operands,
                'instruction'
            );

            if ($check_field_dt_exist !== true &&
                $check_field_instr_exist !== true) {
                    
                $check_field_exist = array_intersect(
                    $check_field_dt_exist,
                    $check_field_instr_exist
                );
                if (count($check_field_exist) === 0) {
                    $check_field_exist = true;
                }
            } else {
                $check_field_exist = true;
            }

        } else {
            // Vérifie les champs utilisés pour la règle
            $check_field_exist = $this->f->check_field_exist($operands, 'instruction');
        }

        if ($check_field_exist !== true) {

            // Liste des champs en erreur
            $string_error_fields = implode(', ', $check_field_exist);

            // Message d'erreur
            $error_msg = __("Le champ %s n'est pas utilisable pour le champ %s.");
            // Si plusieurs champs sont en erreur
            if (count($check_field_exist) > 1) {
                $error_msg = __("Les champs %s ne sont pas utilisables pour le champ %s.");
            }

            // Affiche l'erreur
            $this->correct=false;
            $this->addToMessage(
                sprintf(
                    $error_msg,
                    '<b>'.$string_error_fields.'</b>',
                    '<b>'.__($rule_name).'</b>'
                )
            );
        }
    }

    /**
     * 
     */
    function formSpecificContent($maj) {
        /**
         * Affichage des champs qu'il est possible d'utiliser dans les règles
         */
        // Archives du dossier
        echo '<h4>'.__("Valeurs du dossier avant l'evenement").'</h4>';
        echo '[archive_etat] [archive_delai] [archive_accord_tacite] 
        [archive_avis]';
        echo '<br/>';
        echo '[archive_date_dernier_depot] [archive_date_complet] 
        [archive_date_rejet] [archive_date_limite] 
        [archive_date_notification_delai] [archive_date_decision] 
        [archive_date_validite] [archive_date_achevement] 
        [archive_date_conformite] [archive_date_chantier] 
        [archive_etat_pendant_incompletude] [archive_date_limite_incompletude]
        [archive_delai_incompletude] [archive_autorite_competente] 
        [archive_date_cloture_instruction] [archive_date_premiere_visite]
        [archive_date_derniere_visite] [archive_date_contradictoire]
        [archive_date_retour_contradictoire] [archive_date_ait]
        [archive_date_transmission_parquet]
        [archive_incompletude] [archive_incomplet_notifie]
        [duree_validite][date_depot][date_depot_mairie]';
        // Champs de l'événement
        echo '<h4>'.__("Parametres de l'evenement").'</h4>';
        echo '[' . implode('] [', self::EVENEMENT_FIELDS) . ']';
        // Champs récupérés depuis l'événement d'instruction principal
        echo '<h4>'.__("Valeurs de l'evenement d'instruction principal").'</h4>';
        echo '[date_envoi_signature] [date_retour_signature] [date_envoi_rar] [date_retour_rar] [date_envoi_rar] [date_retour_rar] [date_envoi_controle_legalite] [date_retour_controle_legalite]';
        // Champs du type détaillé du dossier d'autorisation
        echo '<h4>'.__("Parametres du type detaille du dossier d'autorisation")
            .'</h4>';
        echo '[duree_validite_parametrage]';
        // Champs du type détaillé du dossier d'autorisation
        echo '<h4>'.__('Valeurs des données techniques')
            .'</h4>';
        echo '[ctx_nature_travaux_infra_om_html] [ctx_article_non_resp_om_html]';
        echo '<h4>'.__('Suppression de la valeur').'</h4>';
        echo '[null]';
        echo '<h4>'.__('Valeurs pour les booléens').'</h4>';
        echo '[f] ou [false] [t] ou [true]';
    }

}


1	mbroquet	3730	<?php
2			/**
3	nhaye	5254	* DBFORM - 'action' - Surcharge gen.
4	mbroquet	3730	*
5	nhaye	5254	* Ce script permet de définir la classe 'action'.
6			*
7			* @package openads
8			* @version SVN : $Id$
9	mbroquet	3730	*/
10
11			require_once "../gen/obj/action.class.php";
12
13			class action extends action_gen {
14
15			// Handler d'un objet de classe dossier
16			var $dossier;
17
18	softime	17542	// Liste des regles de dates
19			var $date_rules = array(
20			'regle_delai',
21			'regle_delai_incompletude',
22			'regle_date_limite',
23			'regle_date_notification_delai',
24			'regle_date_complet',
25			'regle_date_validite',
26			'regle_date_decision',
27			'regle_date_chantier',
28			'regle_date_achevement',
29			'regle_date_conformite',
30			'regle_date_rejet',
31			'regle_date_dernier_depot',
32			'regle_date_limite_incompletude',
33			'regle_date_cloture_instruction',
34			'regle_date_premiere_visite',
35			'regle_date_derniere_visite',
36			'regle_date_contradictoire',
37			'regle_date_retour_contradictoire',
38			'regle_date_ait',
39			'regle_date_transmission_parquet',
40			'regle_date_affichage',
41			);
42
43	softime	19307	const EVENEMENT_FIELDS = array(
44			'etat',
45			'delai',
46			'accord_tacite',
47			'avis_decision',
48			'delai_notification',
49			'date_evenement',
50			'autorite_competente',
51			'pec_metier',
52			'complement_om_html',
53			'complement2_om_html',
54			'complement3_om_html',
55			'complement4_om_html',
56			);
57
58	softime	17542	function setValF($val = array()) {
59			parent::setValF($val);
60			foreach ($this->date_rules as $key => $rule){
61			$this->valF[$rule] = $this->f->formatage_regles($this->valF[$rule]);
62			}
63			}
64
65	softime	6565	function setType(&$form, $maj) {
66			parent::setType($form, $maj);
67
68	softime	18876	if ($maj == 0 \|\| $maj == 1) {
69	softime	6565	$form->setType("regle_donnees_techniques1", "regle_donnees_techniques");
70			$form->setType("regle_donnees_techniques2", "regle_donnees_techniques");
71			$form->setType("regle_donnees_techniques3", "regle_donnees_techniques");
72			$form->setType("regle_donnees_techniques4", "regle_donnees_techniques");
73			$form->setType("regle_donnees_techniques5", "regle_donnees_techniques");
74			$form->setType("cible_regle_donnees_techniques1", "nodisplay");
75			$form->setType("cible_regle_donnees_techniques2", "nodisplay");
76			$form->setType("cible_regle_donnees_techniques3", "nodisplay");
77			$form->setType("cible_regle_donnees_techniques4", "nodisplay");
78			$form->setType("cible_regle_donnees_techniques5", "nodisplay");
79			}
80	softime	18876	if ($maj == 2 \|\| $maj == 3) {
81	softime	6565	$form->setType("regle_donnees_techniques1", "regle_donnees_techniques_static");
82			$form->setType("regle_donnees_techniques2", "regle_donnees_techniques_static");
83			$form->setType("regle_donnees_techniques3", "regle_donnees_techniques_static");
84			$form->setType("regle_donnees_techniques4", "regle_donnees_techniques_static");
85			$form->setType("regle_donnees_techniques5", "regle_donnees_techniques_static");
86			$form->setType("cible_regle_donnees_techniques1", "nodisplay");
87			$form->setType("cible_regle_donnees_techniques2", "nodisplay");
88			$form->setType("cible_regle_donnees_techniques3", "nodisplay");
89			$form->setType("cible_regle_donnees_techniques4", "nodisplay");
90			$form->setType("cible_regle_donnees_techniques5", "nodisplay");
91			}
92			}
93
94			function setLib(&$form, $maj) {
95			parent::setLib($form, $maj);
96	softime	17542	$form->setLib('regle_etat',__('Règle état'));
97			$form->setLib('regle_delai',__('Règle delai (DATE)'));
98			$form->setLib('regle_accord_tacite',__('Règle accord tacite (UNIQUE)'));
99			$form->setLib('regle_avis',__('Règle avis'));
100			$form->setLib('regle_date_limite',__('Règle date limite (DATE)'));
101			$form->setLib('regle_date_notification_delai',__('Règle date de délai de notification (DATE)'));
102			$form->setLib('regle_date_complet',__('Règle date complet (DATE)'));
103			$form->setLib('regle_date_validite',__('Règle date de validite (DATE)'));
104			$form->setLib('regle_date_decision',__('Règle date de décision (DATE)'));
105			$form->setLib('regle_date_chantier',__('Règle date de chantier (DATE)'));
106			$form->setLib('regle_date_achevement',__("Règle date d'achevement (DATE)"));
107			$form->setLib('regle_date_conformite',__('Règle date de conformite (DATE)'));
108			$form->setLib('regle_date_rejet',__('Règle date rejet (DATE)'));
109			$form->setLib('regle_date_dernier_depot',__('règle date de dernier dépot (DATE)'));
110			$form->setLib('regle_date_limite_incompletude',__("Règle date limite d'incomplétude (DATE)"));
111			$form->setLib('regle_delai_incompletude',__("Règle delai d'incomplétude (DATE)"));
112			$form->setLib('regle_autorite_competente',__('Règle autorité compétente (UNIQUE)'));
113			$form->setLib('regle_date_cloture_instruction',__("Règle date de clôture de l'instruction (DATE)"));
114			$form->setLib('regle_date_premiere_visite',__("Règle date de première visite (DATE)"));
115			$form->setLib('regle_date_derniere_visite',__("Règle date de dernière visite (DATE)"));
116			$form->setLib('regle_date_contradictoire',__("Règle date de contradictoire (DATE)"));
117			$form->setLib('regle_date_retour_contradictoire',__("Règle date de retour de contradictoire (DATE)"));
118			$form->setLib('regle_date_ait',__("Règle date AIT (DATE)"));
119			$form->setLib('regle_date_transmission_parquet',__("Règle date de transmission au Parquet (DATE)"));
120
121			$form->setLib('regle_donnees_techniques1',__('Règle donnée techniques / CERFA n°1'));
122			$form->setLib('regle_donnees_techniques2',__('Règle donnée techniques / CERFA n°2'));
123			$form->setLib('regle_donnees_techniques3',__('Règle donnée techniques / CERFA n°3'));
124			$form->setLib('regle_donnees_techniques4',__('Règle donnée techniques / CERFA n°4'));
125			$form->setLib('regle_donnees_techniques5',__('Règle donnée techniques / CERFA n°5'));
126
127			$form->setLib('cible_regle_donnees_techniques1',__('Champ cible de la règle donnée technique n°1'));
128			$form->setLib('cible_regle_donnees_techniques2',__('Champ cible de la règle donnée technique n°2'));
129			$form->setLib('cible_regle_donnees_techniques3',__('Champ cible de la règle donnée technique n°3'));
130			$form->setLib('cible_regle_donnees_techniques4',__('Champ cible de la règle donnée technique n°4'));
131			$form->setLib('cible_regle_donnees_techniques5',__('Champ cible de la règle donnée technique n°5'));
132
133			$form->setLib('regle_dossier_instruction_type',__("Règle type de dossier d'instruction (NUMERIQUE)"));
134			$form->setLib('regle_date_affichage',__("Règle date d'affichage (DATE)"));
135			$form->setLib('regle_pec_metier',__("Règle prise en compte métier (UNIQUE)"));
136			$form->setLib('regle_a_qualifier',__("Règle à qualifier (BOOLEAN)"));
137			$form->setLib('regle_incompletude',__("Règle incomplétude (BOOLEAN)"));
138			$form->setLib('regle_incomplet_notifie',__("Règle incomplétude notifiée (BOOLEAN)"));
139			$form->setLib('regle_etat_pendant_incompletude',__("Règle état du dossier pendant l'incomplétude (UNIQUE)"));
140			$form->setLib('regle_evenement_suivant_tacite_incompletude',__("Règle événement suivant tacite de l'événement s'applique lors de
141			l'incomplétude notifiée (BOOLEAN)"));
142	softime	6565	}
143
144	softime	8989	/**
145			* @return void
146			*/
147			function verifier($val = array(), &$dnu1 = null, $dnu2 = null) {
148			parent::verifier($val);
149			//
150	mbroquet	3730	$list_column = array();
151			// Mot-clés à rechercher
152			$search_field = "regle_";
153			// Pour chaque champs du formulaire
154			foreach ($this->champs as $champ) {
155			// Si le mot-clés est présent dans l'identifiant du champ
156			if (strpos($champ, $search_field) !== false) {
157			// Ajoute le champ à la liste
158			$list_column[] = $champ;
159			}
160			}
161
162			//
163			$list_fields = array();
164			// Pour chaque colonne
165			foreach ($list_column as $value) {
166
167			// Vérifie que le champs existe dans le formulaire et qu'il n'est
168			// pas vide
169			if (isset($this->valF[$value])
170			&& $this->valF[$value] != ''
171	softime	17542	&& $this->valF[$value] != null) {
172	mbroquet	3730	//
173			$list_fields[$value] = $this->valF[$value];
174			}
175			}
176
177			// Si le tableau contenant les champs à tester n'est pas vide
178			if (count($list_fields) > 0) {
179
180			//
181			foreach ($list_fields as $key => $value) {
182
183			// Vérification de la possibilité des champs de la table dossier
184			// correspondants aux règles d'être mis à null
185	softime	18876	if($this->valF[$key] == "NULL" \|\| $this->valF[$key] == "null") {
186	mbroquet	3730	//
187			if($this->fieldCanBeNull(substr($key, 6)) === false) {
188			// Affiche l'erreur
189			$this->correct=false;
190	softime	18876	$error_message = __("Le champ %s des dossiers ne peut etre mis a NULL.");
191			$this->addToMessage(sprintf($error_message, "<b>".__(substr($key, 6))."</b>"));
192	mbroquet	3730
193			}
194			}
195
196			// Vérifie que la règle est valide
197			$this->rule_is_valid($value, $key);
198			}
199			}
200
201	softime	6565	// Vérification de la présence du couple cible règle pour les DT
202			for ($i = 1; $i < 6; $i++) {
203			if ($this->valF["regle_donnees_techniques".$i] === null XOR
204			$this->valF["cible_regle_donnees_techniques".$i] === null) {
205
206			$this->correct=false;
207			$this->addToMessage(
208			sprintf(
209	softime	18876	__("Le champ <b>Règle données techniques / CERFA</b> %s ne peut comporter un champ rempli et un champ vide"),
210	softime	6565	$i
211			)
212			);
213			}
214			}
215
216
217	mbroquet	3730	}
218
219			/**
220			* Vérification que les champs ciblés par les règles contenant NULL peuvent
221			* l'être.
222			* @param string $field champ impacté par la règle
223			* @return boolean peut être null = true else false
224			*/
225			function fieldCanBeNull($field) {
226			// Instantiation de la classe dossier si pas déjà fait
227	softime	18876	if(!isset($this->dossier) \|\| empty($this->dossier)) {
228	softime	7996	$this->dossier = $this->f->get_inst__om_dbform(array(
229			"obj" => "dossier",
230			"idx" => "]",
231			));
232	mbroquet	3730	}
233			// Si le champ passé en param est dans la liste des champs obligatoires
234			// de la table dossier return false
235			if(array_search($field, $this->dossier->required_field) !== false) {
236			return false;
237			}
238			return true;
239			}
240
241			/**
242			* Vérifie la validité d'une règle d'action.
243	softime	6565	*
244			* @param string $rule Règle d'action.
245			* @param string $rule_name Nom de la règle.
246	mbroquet	3730	*/
247	softime	17542	function rule_is_valid($rule, $rule_name) {
248			// Liste des régles de type 'champ de BDD'
249			$cible_donnees_techniques_rules = array(
250			'cible_regle_donnees_techniques1',
251			'cible_regle_donnees_techniques2',
252			'cible_regle_donnees_techniques3',
253			'cible_regle_donnees_techniques4',
254			'cible_regle_donnees_techniques5',
255			);
256	mbroquet	3730
257	softime	17542	// Liste des régles a Opérateur unique
258			$unique_operand_rules = array(
259			'regle_autorite_competente',
260			'regle_etat',
261			'regle_accord_tacite',
262			'regle_pec_metier',
263			'regle_etat_pendant_incompletude',
264			);
265	mbroquet	3730
266	softime	17542	$common_rules = array(
267			'regle_etat',
268			'regle_accord_tacite',
269			'regle_avis',
270			'regle_autorite_competente',
271			'regle_donnees_techniques1',
272			'regle_donnees_techniques2',
273			'regle_donnees_techniques3',
274			'regle_donnees_techniques4',
275			'regle_donnees_techniques5',
276			'regle_pec_metier',
277			'regle_etat_pendant_incompletude',
278			);
279
280			$boolean_rules = array_merge(
281			$common_rules,
282			array(
283			'regle_a_qualifier',
284			'regle_incompletude',
285			'regle_incomplet_notifie',
286			'regle_evenement_suivant_tacite_incompletude',
287			)
288			);
289
290			$numeric_rules = array_merge(
291			$common_rules,
292			array(
293			'regle_dossier_instruction_type',
294			)
295			);
296
297	softime	6565	// Si la règle à vérifier concerne les données techniques, il faut
298			// récupérer le type du champ des données techniques sélectionné.
299	softime	17542	if (in_array($rule_name, $cible_donnees_techniques_rules, true) === true) {
300	softime	6565	// Récupération du type de champ de la cible de la règle
301			$type = $this->f->get_type_from_db(
302			'donnees_techniques',
303			$this->valF[$rule_name]
304			);
305			if (isset($type[$this->valF[$rule_name]]) === false
306			\|\| $type[$this->valF[$rule_name]] !== 'text') {
307			$this->correct=false;
308			$this->addToMessage(
309			sprintf(
310	softime	17542	__('Le champ %s ne peut être que de type texte.'),
311			'<b>'.__($rule_name).'</b>'
312	softime	6565	)
313			);
314			}
315			}
316
317	softime	17542	// Gestion du null
318			$is_null_result = $this->f->rule_null_is_valid($rule, $rule_name);
319			if ( is_array($is_null_result) === true ){
320			if ( $is_null_result[0] === false ){
321			// Affiche l'erreur
322			$this->correct=$is_null_result[0];
323			$this->addToMessage($is_null_result[1]);
324			}
325			return null;
326			}
327
328			// Supprime tous les espaces de la chaîne de caractère
329			$rule = str_replace(' ', '', $rule);
330			// Coupe la chaîne au niveau de l'opérateur
331			$operands = explode('+', $rule);
332			// Nombre d'opérande
333			$nb_operands = count($operands);
334
335			// Si c'est une règle spécifique unique
336			if (in_array($rule_name, $unique_operand_rules, true) === true) {
337			// S'il y à plus d'une opérande
338	mbroquet	3730	if ($nb_operands > 1) {
339			// Message d'erreur
340			$this->correct=false;
341			$this->addToMessage(
342	softime	18876	sprintf(__("Le champ %s ne peut pas avoir plus d'un opérande."),
343			'<b>'.__($rule_name).'</b>')
344	mbroquet	3730	);
345	softime	17542	return null;
346	mbroquet	3730	}
347			}
348
349			// Pour chaque opérande
350			foreach ($operands as $key => $operand) {
351	softime	17542	// si on as une chaine +xmois ou +xjour(s) pour une regle de type date
352			if (in_array($rule_name, $this->date_rules, true) === true) {
353			$is_date_result = $this->f->rule_date_is_valid($operand, $rule_name);
354			if ( is_array($is_date_result) === true ){
355			if ( $is_date_result[0] === false ){
356			// Affiche l'erreur
357			$this->correct=$is_date_result[0];
358			$this->addToMessage($is_date_result[1]);
359			return null;
360			}
361			// Supprime l'opérande
362			unset($operands[$key]);
363			}
364			}
365	mbroquet	3730
366	softime	17542	// Supprime les numériques pour les regles acceptant le numérique
367			if (
368			in_array($rule_name, $numeric_rules, true) === true
369			&& is_numeric($operand)
370			) {
371	mbroquet	3730	// Supprime l'opérande
372			unset($operands[$key]);
373			}
374	softime	17542
375			// Supprime également les booléens pour les regles acceptant les booleans
376			if (
377			in_array($rule_name, $boolean_rules, true) === true
378			&& ($operand == 'f' \|\| $operand == 't'
379			\|\| $operand == 'false' \|\| $operand == 'true')
380			) {
381	mbroquet	3730	// Supprime l'opérande
382			unset($operands[$key]);
383			}
384			}
385	softime	17542
386	softime	6565	$rules = array(
387			'regle_donnees_techniques1',
388			'regle_donnees_techniques2',
389			'regle_donnees_techniques3',
390			'regle_donnees_techniques4',
391			'regle_donnees_techniques5',
392			'cible_regle_donnees_techniques1',
393			'cible_regle_donnees_techniques2',
394			'cible_regle_donnees_techniques3',
395			'cible_regle_donnees_techniques4',
396			'cible_regle_donnees_techniques5',
397			);
398	mbroquet	3730
399	softime	6565	if (in_array($rule_name, $rules, true) === true) {
400
401			// Vérification de l'existance des champs de règle dans les données
402			// technique
403			$check_field_dt_exist = $this->f->check_field_exist(
404			$operands,
405			'donnees_techniques'
406			);
407	softime	17542
408	softime	6565	$check_field_instr_exist = $this->f->check_field_exist(
409			$operands,
410			'instruction'
411			);
412
413	softime	18876	if ($check_field_dt_exist !== true &&
414	softime	6565	$check_field_instr_exist !== true) {
415
416			$check_field_exist = array_intersect(
417			$check_field_dt_exist,
418			$check_field_instr_exist
419			);
420			if (count($check_field_exist) === 0) {
421			$check_field_exist = true;
422			}
423			} else {
424			$check_field_exist = true;
425			}
426	softime	17542
427	softime	6565	} else {
428			// Vérifie les champs utilisés pour la règle
429			$check_field_exist = $this->f->check_field_exist($operands, 'instruction');
430			}
431
432	mbroquet	3730	if ($check_field_exist !== true) {
433
434			// Liste des champs en erreur
435	softime	17542	$string_error_fields = implode(', ', $check_field_exist);
436	mbroquet	3730
437			// Message d'erreur
438	softime	18876	$error_msg = __("Le champ %s n'est pas utilisable pour le champ %s.");
439	mbroquet	3730	// Si plusieurs champs sont en erreur
440			if (count($check_field_exist) > 1) {
441	softime	18876	$error_msg = __("Les champs %s ne sont pas utilisables pour le champ %s.");
442	mbroquet	3730	}
443
444			// Affiche l'erreur
445			$this->correct=false;
446	softime	6565	$this->addToMessage(
447			sprintf(
448			$error_msg,
449			'<b>'.$string_error_fields.'</b>',
450	softime	18876	'<b>'.__($rule_name).'</b>'
451	softime	6565	)
452			);
453	mbroquet	3730	}
454			}
455
456			/**
457	softime	17542	*
458	mbroquet	3730	*/
459			function formSpecificContent($maj) {
460			/**
461			* Affichage des champs qu'il est possible d'utiliser dans les règles
462			*/
463			// Archives du dossier
464	softime	17542	echo '<h4>'.__("Valeurs du dossier avant l'evenement").'</h4>';
465			echo '[archive_etat] [archive_delai] [archive_accord_tacite]
466			[archive_avis]';
467			echo '<br/>';
468			echo '[archive_date_dernier_depot] [archive_date_complet]
469	mbroquet	3730	[archive_date_rejet] [archive_date_limite]
470			[archive_date_notification_delai] [archive_date_decision]
471			[archive_date_validite] [archive_date_achevement]
472			[archive_date_conformite] [archive_date_chantier]
473			[archive_etat_pendant_incompletude] [archive_date_limite_incompletude]
474			[archive_delai_incompletude] [archive_autorite_competente]
475	softime	6565	[archive_date_cloture_instruction] [archive_date_premiere_visite]
476			[archive_date_derniere_visite] [archive_date_contradictoire]
477			[archive_date_retour_contradictoire] [archive_date_ait]
478			[archive_date_transmission_parquet]
479	softime	10573	[archive_incompletude] [archive_incomplet_notifie]
480	softime	17542	[duree_validite][date_depot][date_depot_mairie]';
481	mbroquet	3730	// Champs de l'événement
482	softime	17542	echo '<h4>'.__("Parametres de l'evenement").'</h4>';
483	softime	19307	echo '[' . implode('] [', self::EVENEMENT_FIELDS) . ']';
484	mbroquet	3730	// Champs récupérés depuis l'événement d'instruction principal
485	softime	17542	echo '<h4>'.__("Valeurs de l'evenement d'instruction principal").'</h4>';
486			echo '[date_envoi_signature] [date_retour_signature] [date_envoi_rar] [date_retour_rar] [date_envoi_rar] [date_retour_rar] [date_envoi_controle_legalite] [date_retour_controle_legalite]';
487	mbroquet	3730	// Champs du type détaillé du dossier d'autorisation
488	softime	17542	echo '<h4>'.__("Parametres du type detaille du dossier d'autorisation")
489			.'</h4>';
490			echo '[duree_validite_parametrage]';
491	softime	6565	// Champs du type détaillé du dossier d'autorisation
492	softime	17542	echo '<h4>'.__('Valeurs des données techniques')
493			.'</h4>';
494			echo '[ctx_nature_travaux_infra_om_html] [ctx_article_non_resp_om_html]';
495			echo '<h4>'.__('Suppression de la valeur').'</h4>';
496			echo '[null]';
497			echo '<h4>'.__('Valeurs pour les booléens').'</h4>';
498			echo '[f] ou [false] [t] ou [true]';
499	mbroquet	3730	}
500
501			}
502
503	softime	7996