source: spip-zone/_plugins_/inscription/trunk/inscription3_pipelines.php @ 104132

Last change on this file since 104132 was 104132, checked in by kent1@…, 5 years ago

Virer la date de naissance nulle du chargement du formulaire

File size: 45.0 KB
Line 
1<?php
2/**
3 * Plugin Inscription3 pour SPIP
4 * © cmtmt, BoOz, kent1
5 * Licence GPL v3
6 *
7 * Utilisations de pipelines
8 *
9 * @package SPIP\Inscription3\Pipelines
10 */
11
12if (!defined('_ECRIRE_INC_VERSION')) {
13        return;
14}
15
16/**
17 *
18 * Insertion dans le pipeline i3_exceptions_chargement_champs_auteurs_elargis (Inscription3)
19 * qui empêche le chargement et la recherche de champs lors de l'affichage de formulaires (editer_auteur / inscription)
20 *
21 * @return array Un tableau des champs correspondant au "name" de son input de configuration dans le CFG
22 * @param array $array Prend un tableau en argument qui doit être complété en fonction des besoins
23 */
24
25function inscription3_i3_exceptions_chargement_champs_auteurs_elargis($array) {
26        // liste des champs pour lesquels on ne doit pas charger la valeur
27        $array[] = 'creation';
28        return $array;
29}
30
31/**
32 *
33 * Insertion dans le pipeline i3_exceptions_des_champs_auteurs_elargis
34 * qui empêche la création de certains champs dans la table
35 * après les avoir configuré
36 *
37 * @return array Un tableau des champs correspondant au "name" de son input de configuration dans le CFG
38 * @param array $array Prend un tableau en argument qui doit être complété en fonction des besoins
39 */
40
41function inscription3_i3_exceptions_des_champs_auteurs_elargis($array) {
42        // liste des champs pour lesquels on ne doit pas créer de champs dans la table spip_auteurs
43
44        // Principalement les champs déjà présents dans spip_auteurs
45        $array[] = 'id_auteur';
46        $array[] = 'bio';
47        $array[] = 'nom';
48        $array[] = 'pass';
49        $array[] = 'login';
50        $array[] = 'email';
51        $array[] = 'statut';
52        $array[] = 'pgp';
53        $array[] = 'url_site';
54        $array[] = 'nom_site';
55
56        // Des choses spécifiques à inscription3
57        $array[] = 'logo';
58        $array[] = 'username';
59        $array[] = 'statut_nouveau';
60        $array[] = 'statut_int';
61        $array[] = 'statut_interne';
62        $array[] = 'accesrestreint';
63        $array[] = 'password';
64        $array[] = 'pass';
65        $array[] = 'affordance_form';
66        $array[] = 'reglement';
67        $array[] = 'reglement_article';
68        $array[] = 'password_complexite';
69        $array[] = 'validation_numero_international';
70        $array[] = 'pays_defaut';
71        $array[] = 'valider_comptes';
72        $array[] = 'message_form_inscription';
73        $array[] = 'auto_login';
74
75        return $array;
76}
77
78/**
79 *
80 * Insertion dans le pipeline i3_verifications_specifiques du plugin inscription3
81 * Utilisation de l'API verifier du plugin éponyme
82 *
83 * Pour chaque champs on fourni un array associatif contenant :
84 * - type => la fonction de l'api de vérification à utiliser
85 * - options => un array des options à passer à cette fonction
86 *
87 * @return array Tableau contenant plusieurs tableaux en fonction du type de champs
88 * @param object $array Doit recevoir un tableau du même type
89 */
90
91function inscription3_i3_verifications_specifiques($array) {
92
93        // Les emails : fonction verifier/email
94        $array['email'] = array('type' => 'email','options' => array('disponible'=>'disponible'));
95        $array['mail_inscription'] = array('type' => 'email','options' => array('disponible'=>'disponible'));
96
97        // Les noms (signature)
98        $array['nom'] = array('type' => 'signature');
99        $array['nom_inscription'] = array('type' => 'signature');
100
101        // Les logins : fonction verifier/login
102        $array['login'] = array('type' => 'login');
103
104        // Les statuts : fonction verifier/statut
105        $array['statut'] = array('type' => 'statut');
106
107        // Les codes postaux : fonction verifier/code_postal
108        $array['code_postal'] = array('type' => 'code_postal');
109
110        // Les numéros de téléphone : fonction verifier/telephone
111        $array['telephone'] = array('type' => 'telephone');
112        $array['fax'] = array('type' => 'telephone');
113        $array['mobile'] = array('type' => 'telephone');
114
115        // Les dates
116        $array['naissance'] = array('type' => 'date','options' => array('format' => 'amj'));
117
118        return $array;
119}
120
121/**
122 * Insertion dans le pipeline affiche_droite (SPIP)
123 *
124 * Dans certaines pages définies, afficher le lien d'accès à la page des comptes utilisateurs
125 *
126 * @return array Le même tableau qu'il reçoit en argument
127 * @param array $flux Un tableau donnant des informations sur le contenu passé au pipeline
128 */
129
130function inscription3_affiche_droite($flux) {
131        if (((preg_match('/^inscription3/', $flux['args']['exec']))
132                or (preg_match('/^auteur/', $flux['args']['exec']))
133                or (preg_match('/^i3_/', $flux['args']['exec']))
134                or ($flux['args']['exec'] == 'configurer_inscription3')
135                or (($flux['args']['exec'] == 'cfg')
136                        and ((_request('cfg') == 'inscription3') or preg_match('/^i3_/', _request('cfg'))))
137                )
138                and ($flux['args']['exec'] != 'inscription3_adherents')) {
139                $flux['data'] .= recuperer_fond('prive/inscription3_affiche_droite');
140        }
141        return $flux;
142}
143
144/**
145 * Insertion dans le pipeline i3_definition_champs
146 *
147 * Définition spécifique des champs qui ne sont pas de type text
148 * Par défaut inscription3 définit les champs comme étant de type texte, cela peut être
149 * différent pour d'autres ...
150 */
151function inscription3_i3_definition_champs($flux) {
152        include_spip('inc/config');
153        /**
154         * Récupération de la configuration d'inscription3
155         * pour éviter d'avoir à utiliser la fonction lire_config beaucoup de fois
156         */
157        $config_i3 = lire_config('inscription3', array());
158
159        $flux['pays'] = array(
160                'saisie' => 'pays', // type de saisie
161                'options' => array(
162                        'sql' => 'int NOT NULL', // declaration sql
163                        'option_intro'=>_T('inscription3:aucun'),
164                        'class' => 'pays',
165                        'defaut' => ((array_key_exists('pays_defaut', $config_i3)
166                                and isset($config_i3['pays_defaut'])) ? $config_i3['pays_defaut'] : ''),
167                        'obligatoire' => (array_key_exists('pays_obligatoire', $config_i3)
168                                and $config_i3['pays_obligatoire'] == 'on') ? true : false,
169                        'rechercher' => false
170                )
171        );
172        $flux['validite'] = array(
173                'saisie' => 'date_jour_mois_annee', // type de saisie
174                'options'=> array(
175                        'sql' => "datetime DEFAULT '0000-00-00 00:00:00' NOT NULL", // declaration sql
176                        'obligatoire' => (array_key_exists('validite_obligatoire', $config_i3)
177                                and $config_i3['validite_obligatoire'] == 'on') ? true : false,
178                        'rechercher' => false
179                ),
180                'verifier' => array(
181                        'type' => 'date',
182                        'options' => array(
183                                'format' => 'amj'
184                        )
185                )
186        );
187        $flux['creation'] = array(
188                'saisie' => 'date_jour_mois_annee', // type de saisie
189                'options' => array(
190                        'sql' => "datetime DEFAULT '0000-00-00 00:00:00' NOT NULL", // declaration sql
191                        'rechercher' => false
192                ),
193                'restrictions' => array(
194                        'voir' => array('auteur' => ''),
195                        'modifier' => array('auteur' => 'webmestre')
196                )
197        );
198        $flux['naissance'] = array(
199                'saisie' => 'date_jour_mois_annee', // type de saisie
200                'options' => array(
201                        'sql' => "DATE DEFAULT '0000-00-00' NOT NULL", // declaration sql
202                        'obligatoire' => (array_key_exists('naissance_obligatoire', $config_i3)
203                                and $config_i3['naissance_obligatoire'] == 'on') ? true : false,
204                        'class'=>'nomulti',
205                        'datetime'=>'non',
206                        'rechercher' => false
207                ),
208                'verifier' => array(
209                        'type' => 'date',
210                        'options' => array(
211                                'format' => 'amj'
212                        )
213                )
214        );
215        $flux['sexe'] = array(
216                'saisie' => 'radio', // type de saisie
217                'options' => array(
218                        'label'=> _T('inscription3:label_civilite'),
219                        'datas'=> array(
220                                'F' => _T('inscription3:choix_feminin'),
221                                'M' => _T('inscription3:choix_masculin')
222                        ),
223                        'sql' => "varchar(2) NOT NULL default ''", // declaration sql
224                        'obligatoire' => (array_key_exists('sexe_obligatoire', $config_i3)
225                                and $config_i3['sexe_obligatoire'] == 'on') ? true : false,
226                        'rechercher' => false
227                )
228        );
229
230        $flux['commentaire']['saisie'] = 'textarea';
231        $flux['commentaire']['options'] = array_merge(((isset($flux['commentaire']['options'])
232                and is_array($flux['commentaire']['options'])) ?
233                        $flux['commentaire']['options'] : array()), array('rows' => 5,'class' => 'adresse'));
234
235        $flux['adresse']['saisie'] = 'textarea';
236        $flux['adresse']['options'] = array_merge(((isset($flux['adresse']['options'])
237                and is_array($flux['adresse']['options'])) ?
238                        $flux['adresse']['options'] : array()), array('rows' => 5, 'class' => 'adresse'));
239
240        $flux['telephone']['verifier']['type'] = 'telephone';
241        $flux['telephone']['options'] = array('class'=>'nomulti');
242
243        $flux['fax']['verifier'] = 'telephone';
244        $flux['fax']['options'] = array('class'=>'nomulti');
245
246        $flux['mobile']['verifier']['type'] = 'telephone';
247        $flux['mobile']['options'] = array('class'=>'nomulti');
248
249        $flux['code_postal']['verifier']['type'] = 'code_postal';
250        $flux['code_postal']['options']['class'] = 'nomulti';
251
252        return $flux;
253}
254
255/**
256 * Insertion dans le pipeline formulaire_charger (SPIP)
257 *
258 * Charge des valeurs spécifiques dans le formulaire d'inscription
259 *
260 * @param array $flux Le contexte d'environnement du pipeline
261 * @return array $flux Le contexte d'environnement modifié
262 */
263function inscription3_formulaire_charger($flux) {
264        if ($flux['args']['form']=='inscription') {
265                $valeurs = array();
266                $chercher_champs = charger_fonction('inscription3_champs_formulaire', 'inc');
267                $champs = $chercher_champs(null, 'inscription');
268                foreach ($champs as $valeur) {
269                        $valeurs[$valeur] = _request($valeur);
270                        if (is_array($valeurs[$valeur])) {
271                                $valeurs[$valeur] = implode(',', $valeurs[$valeur]);
272                        }
273                        $valeurs[$valeur] = trim($valeurs[$valeur]);
274                        if ($valeur == 'naissance') {
275                                $date_naissance = array();
276                                if (_request('naissance')
277                                        and preg_match('/([0-9]{4})-([0-9]{2})-([0-9]{2})/', _request('naissance'), $date_naissance)) {
278                                        $valeurs['naissance_annee'] = $date_naissance[1];
279                                        $valeurs['naissance_mois'] = $date_naissance[2];
280                                        $valeurs['naissance_jour'] = $date_naissance[3];
281                                } else {
282                                        $valeurs['naissance_annee'] = _request('naissance_annee') ? _request('naissance_annee') : '';
283                                        $valeurs['naissance_mois'] = _request('naissance_mois') ? _request('naissance_mois') : '';
284                                        $valeurs['naissance_jour'] = _request('naissance_jour') ? _request('naissance_jour') : '';
285                                }
286                        }
287                }
288                include_spip('cextras_pipelines');
289                $saisies = champs_extras_objet('spip_auteurs');
290                foreach ($champs as $valeur) {
291                        if (!$valeurs[$valeur]) {
292                                if (array_key_exists($valeur, $saisies)) {
293                                        $saisie_nom = $saisies[$valeur]['options']['nom'];
294                                        if (_request($saisie_nom)) {
295                                                $valeurs[$saisie_nom] = trim(_request($saisie_nom));
296                                        }
297                                }
298                        }
299                }
300                $valeurs = pipeline(
301                        'i3_charger_formulaire',
302                        array(
303                                'args' => $flux['args'],
304                                'data' => $valeurs
305                        ),
306                        array()
307                );
308
309                if (is_array($flux['data'])) {
310                        $flux['data'] = array_merge($flux['data'], $valeurs);
311                } else {
312                        $flux['data'] = $valeurs;
313                }
314        }
315
316        if (in_array($flux['args']['form'], array('editer_auteur', 'inscription'))
317                and (isset($flux['data']['naissance']) and $flux['data']['naissance'] == '0000-00-00')) {
318                unset($flux['data']['naissance']);
319                unset($flux['data']['naissance_annee']);
320                unset($flux['data']['naissance_mois']);
321                unset($flux['data']['naissance_jour']);
322        }
323
324        return $flux;
325}
326
327/**
328 * Insertion dans le pipeline formulaire_verifier (SPIP)
329 *
330 * Vérifie des valeurs spécifiques dans le formulaire d'inscription et d'édition d'auteur (pour le logo)
331 *
332 * @pipeline formulaire_verifier
333 * @param array $flux
334 *              Le contexte d'environnement du pipeline
335 * @return array $flux
336 *              Le contexte d'environnement modifié
337 */
338function inscription3_formulaire_verifier($flux) {
339        include_spip('inc/config');
340        if ($flux['args']['form'] == 'configurer_inscription3') {
341                /**
342                 * On supprime l'ancienne configuration pour avoir la nouvelle dans l'ordre
343                 */
344                include_spip('inc/meta');
345                effacer_meta('inscription3');
346        }
347        if ($flux['args']['form']=='oubli') {
348                $erreurs = $flux['args']['erreurs'];
349                if (!$erreurs or (count($erreurs) == 0)) {
350                        $email = _request('oubli');
351                        if (!empty($email)) {
352                                $statut = sql_getfetsel('statut', 'spip_auteurs', 'email='.sql_quote($email));
353                                if ($statut == '8aconfirmer') {
354                                        $flux['data']['oubli'] = _T('inscription3:erreur_compte_attente_mail');
355                                        $flux['data']['message_erreur'] = _T('inscription3:erreur_compte_attente');
356                                }
357                        } else {
358                                $erreurs['email'] = 'Champ email vide';
359                        }
360                }
361        }
362
363        if (in_array($flux['args']['form'], array('editer_auteur', 'inscription'))) {
364                /**
365                 * On inclue inscription3_fonctions pour prendre en compte la surcharge de
366                 * formulaires_inscription_traiter en ajax
367                 */
368                $erreurs = $flux['data'];
369
370                include_spip('inscription3_fonctions');
371                include_spip('inc/editer');
372                $config_i3 = lire_config('inscription3', array());
373                if ($erreurs['message_erreur'] == null) {
374                        unset($erreurs['message_erreur']);
375                }
376
377                /**
378                 * Vérifier le logo
379                 */
380                if (isset($_FILES['logo']) and ($_FILES['logo']['error'] == 0)) {
381                        $f =_DIR_LOGOS . rand() . '.tmp';
382                        include_spip('inc/documents');
383                        if ($erreur = check_upload_error($_FILES['logo']['error'], '', $f)) {
384                                $erreurs['logo'] = $erreur;
385                        } else {
386                                $source = deplacer_fichier_upload($_FILES['logo']['tmp_name'], $f);
387                        }
388
389                        if ($source and $f) {
390                                global $formats_logos;
391                                $size = @getimagesize($f);
392                                $type = !$size ? '': ($size[2] > 3 ? '' : $formats_logos[$size[2]-1]);
393                                if ($type) {
394                                        $poids = filesize($f);
395
396                                        if (_LOGO_MAX_SIZE > 0
397                                                and $poids > _LOGO_MAX_SIZE*1024) {
398                                                spip_unlink($f);
399                                                $erreur = _T(
400                                                        'info_logo_max_poids',
401                                                        array(
402                                                                'maxi' => taille_en_octets(_LOGO_MAX_SIZE*1024),
403                                                                'actuel' => taille_en_octets($poids)
404                                                        )
405                                                );
406                                        } elseif (_LOGO_MAX_WIDTH * _LOGO_MAX_HEIGHT
407                                                and ($size[0] > _LOGO_MAX_WIDTH
408                                                or $size[1] > _LOGO_MAX_HEIGHT)) {
409                                                spip_unlink($f);
410                                                $erreur = _T(
411                                                        'info_logo_max_poids',
412                                                        array(
413                                                                'maxi' => _T(
414                                                                        'info_largeur_vignette',
415                                                                        array(
416                                                                                'largeur_vignette' => _LOGO_MAX_WIDTH,
417                                                                                'hauteur_vignette' => _LOGO_MAX_HEIGHT
418                                                                        )
419                                                                ),
420                                                                'actuel' => _T(
421                                                                        'info_largeur_vignette',
422                                                                        array(
423                                                                                'largeur_vignette' => $size[0],
424                                                                                'hauteur_vignette' => $size[1]
425                                                                        )
426                                                                )
427                                                        )
428                                                );
429                                        }
430                                        spip_unlink($f);
431                                } else {
432                                        spip_unlink($f);
433                                        $erreur = _T(
434                                                'info_logo_format_interdit',
435                                                array('formats' => join(', ', $formats_logos))
436                                        );
437                                }
438                        }
439
440                        if ($erreur) {
441                                $erreurs['logo'] = $erreur;
442                        }
443                }
444
445                /**
446                 * Vérification des champs obligatoires
447                 * En fonction de ceux présents dans le formulaire
448                 */
449                $champs_obligatoires = charger_fonction('inscription3_champs_obligatoires', 'inc');
450                $obligatoires = $champs_obligatoires(null, $flux['args']['form']);
451                unset($obligatoires['email']);
452                unset($obligatoires['nom']);
453                $erreurs = array_merge($erreurs, formulaires_editer_objet_verifier('auteur', null, $obligatoires));
454
455                if ($flux['args']['form'] == 'inscription') {
456                        if (lire_config('inscription3/pass_obligatoire') == 'on'
457                                and lire_config('inscription3/pass') == 'on'
458                                and (!_request('pass') or !_request('password1'))) {
459                                $erreurs['pass'] = _T('info_obligatoire');
460                        } elseif (lire_config('inscription3/pass') == 'on') {
461                                if (_request('pass') != _request('password1')) {
462                                        $erreurs['pass'] = _T('info_passes_identiques');
463                                } elseif (strlen(_request('pass')) > 0) {
464                                        $pass_min = !defined('_PASS_MIN') ? 6 : _PASS_MIN;
465                                        if (strlen(_request('pass')) < $pass_min) {
466                                                $erreurs['pass'] = _T('info_passe_trop_court');
467                                        }
468                                }
469                        }
470
471                        if ($erreurs['reglement']) {
472                                $erreurs['reglement'] = _T('inscription3:erreur_reglement_obligatoire');
473                        }
474                }
475
476                if (count($erreurs)) {
477                        $erreurs_obligatoires = true;
478                }
479
480                $valeurs = array();
481
482                $verifier = charger_fonction('verifier', 'inc', true);
483
484                if ($verifier) {
485                        /**
486                         * Vérification des champs de champs extras
487                         */
488                        $options = array();
489                        if ($flux['args']['form'] == 'editer_auteur' and intval(_request('id_auteur'))) {
490                                $infos_auteurs = sql_fetsel('*', 'spip_auteurs', 'id_auteur='.intval(_request('id_auteur')));
491                                if (intval($infos_auteurs['id_auteur']) > 0) {
492                                        $options['id_auteur'] = $infos_auteurs['id_auteur'];
493                                }
494                        }
495
496                        $champs_a_verifier = pipeline('i3_verifications_specifiques', array());
497                        //gere la correspondance champs -> _request(champs)
498                        foreach ($champs_a_verifier as $clef => $type) {
499                                /*
500                                 * Si le champs n'est pas déjà en erreur suite aux champs obligatoires
501                                 * On s'assure qu'il est bien présent dans le formulaire également
502                                 */
503                                if ($flux['args']['form'] == 'editer_auteur'
504                                        and intval(_request('id_auteur')) > 0
505                                        and in_array($type['type'], array('email', 'signature'))) {
506                                        if ($type['type'] == 'email' and isset($type['options']['disponible'])
507                                                and $infos_auteurs[$clef] == _request($clef)) {
508                                                unset($type['options']['disponible']);
509                                        } elseif (($type['type'] == 'signature') and ($infos_auteurs[$clef] == _request($clef))) {
510                                                continue;
511                                        }
512                                }
513                                if (!isset($erreurs[$clef]) and _request($clef)) {
514                                        $valeurs[$clef] = trim(_request($clef));
515                                        $type['options'] = array_merge(array_merge(is_array($type['options']) ?
516                                                $type['options'] : array(), $_GET), $options);
517                                        $erreurs[$clef] = $verifier($valeurs[$clef], $type['type'], $type['options']);
518                                        if ($erreurs[$clef] == null) {
519                                                unset($erreurs[$clef]);
520                                        }
521                                }
522                        }
523                        /**
524                         * Vérification des champs de cextras
525                         * Uniquement sur le formulaire d'inscription
526                         *
527                         * On ne vérifie pas les obligatoires qui doivent être faits plus haut
528                         */
529                        if (($flux['args']['form'] == 'inscription')
530                                and $saisies = champs_extras_objet('spip_auteurs')) {
531                                include_spip('inc/autoriser');
532                                include_spip('inc/saisies');
533
534                                $saisies = saisies_lister_avec_sql($saisies);
535
536                                // restreindre la vue selon les autorisations
537                                $id_objet = $flux['args']['args'][0]; // ? vraiment toujours ?
538                                $saisies = champs_extras_autorisation(
539                                        'modifier',
540                                        'auteur',
541                                        $saisies,
542                                        array_merge(
543                                                $flux['args'],
544                                                array(
545                                                        'id' => $id_objet,
546                                                        'contexte' => array()
547                                                )
548                                        )
549                                ); // nous ne connaissons pas le contexte dans ce pipeline
550
551                                foreach ($saisies as $saisie) {
552                                        $nom = $saisie['options']['nom'];
553                                        // verifier (api) + normalisation
554                                        if ($verifier
555                                                and isset($saisie['verifier']['type'])
556                                                and $verif = $saisie['verifier']['type']) {
557                                                $options = isset($saisie['verifier']['options']) ? $saisie['verifier']['options'] : array();
558                                                $normaliser = null;
559                                                if ($erreur = $verifier(_request($nom), $verif, $options, $normaliser)) {
560                                                        $erreurs[$nom] = $erreur;
561                                                } elseif (!is_null($normaliser)) {
562                                                        // si une valeur de normalisation a ete transmis, la prendre.
563                                                        set_request($nom, $normaliser);
564                                                }
565                                        }
566                                }
567                        }
568                }
569                /**
570                 * Naisance est un champs spécifique coupé en trois on le vérifie séparément
571                 * s'il est obligatoire
572                 */
573                if ($erreurs['naissance']) {
574                        $annee = trim(_request('naissance_annee'));
575                        $mois = trim(_request('naissance_mois'));
576                        $jour = trim(_request('naissance_jour'));
577                        if ((!$annee or !$mois or !$jour)
578                                and $config_i3['naissance_obligatoire'] != 'on'
579                                and (trim(_request('naissance')) == '0000-00-00')) {
580                                unset($erreurs['naissance']);
581                        }
582                }
583                if (!$erreurs['naissance'] and _request('naissance') and (_request('naissance') != '0000-00-00')) {
584                        if (_request('naissance_annee') > (date('Y'))) {
585                                $erreurs['naissance'] = _T('inscription3:erreur_naissance_futur');
586                        } elseif (_request('naissance_annee') > (date('Y')-10)) {
587                                $erreurs['naissance'] = _T('inscription3:erreur_naissance_moins_cinq');
588                        } elseif ((date('Y') - _request('naissance_annee')) > 110) {
589                                $erreurs['naissance'] = _T('inscription3:erreur_naissance_plus_110');
590                        }
591                }
592
593                $args = array_merge($flux['args'], array('champs' => $valeurs));
594
595                /**
596                 * Offrir aux autres plugins la possibilite de verifier les donnees
597                 */
598                $erreurs = pipeline(
599                        'i3_verifier_formulaire',
600                        array(
601                                'args' => $args,
602                                'data' => $erreurs
603                        )
604                );
605
606                /**
607                 * Message d'erreur generalise
608                 */
609                if (count($erreurs) and !isset($erreurs['message_erreur'])) {
610                        if (isset($erreurs_obligatoires)) {
611                                $erreurs['message_erreur'] .= _T('inscription3:formulaire_remplir_obligatoires');
612                        } else {
613                                $erreurs['message_erreur'] .= _T('inscription3:formulaire_remplir_validation');
614                        }
615                }
616                $flux['data'] = $erreurs;
617        }
618
619        return $flux;
620}
621
622/**
623 * Insertion dans le pipeline formulaire_traiter (SPIP)
624 *
625 * Traitement des valeurs spécifiques dans le formulaire d'inscription
626 *
627 * @param array $flux Le contexte d'environnement du pipeline
628 * @return array $flux Le contexte d'environnement modifié
629 */
630function inscription3_formulaire_traiter($flux) {
631        if ($flux['args']['form']=='configurer_inscription3') {
632                /**
633                 * Crée les champs dans la table spip_auteurs dès la validation du CFG
634                 */
635                $verifier_tables = charger_fonction('inscription3_verifier_tables', 'inc');
636                $verifier_tables();
637        }
638        if ($flux['args']['form']=='mot_de_passe') {
639                $row = sql_fetsel(
640                        'id_auteur,email,login,source',
641                        'spip_auteurs',
642                        array("statut<>'5poubelle'","pass<>''"),
643                        '',
644                        'maj DESC',
645                        '1'
646                );
647                $affordance = lire_config('inscription3/affordance_form', 'login');
648                switch ($affordance) {
649                        case 'email':
650                                $flux['data']['message_ok'] = _T('pass_nouveau_enregistre').
651                                        '<p>' . _T('inscription3:pass_rappel_email', array('email' => $row['email']));
652                                break;
653                        case 'login_et_email':
654                                $flux['data']['message_ok'] = _T('pass_nouveau_enregistre').
655                                        '<p>' .
656                                        _T(
657                                                'inscription3:pass_rappel_login_email',
658                                                array('email' => $row['email'],'login'=>$row['login'])
659                                        );
660                                break;
661                }
662        }
663        /**
664         * Prise en charge du logo dans le formulaire d'édition d'auteur
665         */
666        if ($flux['args']['form'] == 'editer_auteur') {
667                if (isset($_FILES['logo']) and ($_FILES['logo']['error'] == 0)) {
668                        $id_auteur = $flux['data']['id_auteur'];
669                        if (intval($id_auteur) > 0) {
670                                $chercher_logo = charger_fonction('chercher_logo', 'inc');
671
672                                if ($on = $chercher_logo($id_auteur, 'id_auteur', 'on')) {
673                                        spip_unlink($on[0]);
674                                }
675                                include_spip('formulaires/editer_logo');
676                                include_spip('action/editer_logo');
677                                $sources = formulaire_editer_logo_get_sources();
678                                foreach ($sources as $etat => $file) {
679                                        if ($file and $file['error'] == 0) {
680                                                logo_modifier('auteur', $id_auteur, $etat, $file);
681                                                set_request('logo_up', ' ');
682                                        }
683                                }
684                                // indiquer qu'on doit recalculer les images
685                                $GLOBALS['var_images'] = true;
686                        }
687                } elseif (_request('supprimer_logo') and _request('supprimer_logo') == 'on') {
688                        $id_auteur = $flux['data']['id_auteur'];
689                        if (intval($id_auteur) > 0) {
690                                $chercher_logo = charger_fonction('chercher_logo', 'inc');
691
692                                // supprimer l'ancien logo s'il existe
693                                if ($on = $chercher_logo($id_auteur, 'id_auteur', 'on')) {
694                                        spip_unlink($on[0]);
695                                }
696                        }
697                }
698        }
699        if ($flux['args']['form']=='inscription') {
700                if (!function_exists('lire_config')) {
701                        include_spip('inc/config');
702                }
703                $config_i3 = lire_config('inscription3', array());
704                include_spip('inscription3_fonctions');
705
706                $valeurs = array();
707                /**
708                 * Les valeurs "normales" du formulaire d'inscription
709                 * qui nous permettront de retrouver l'id_auteur
710                 */
711                $nom = _request('nom_inscription');
712                $mail = _request('mail_inscription');
713
714                /**
715                 * A ce moment là SPIP a déjà créé l'auteur et lui a déjà donné un login et pass
716                 */
717                $user = sql_fetsel('*', 'spip_auteurs', 'email='.sql_quote($mail));
718
719                /**
720                 * Si l'on demande le passe dans le formulaire
721                 * On a un mode avec pass fourni
722                 * Sinon un mode simple
723                 */
724                if (($config_i3['pass'] == 'on') and (strlen(_request('pass')))) {
725                        $mode = 'inscription_pass';
726                } else {
727                        $mode = 'inscription';
728                }
729
730                /**
731                 * Generer la liste des champs a traiter
732                 * champ => valeur formulaire
733                 */
734                $chercher_champs = charger_fonction('inscription3_champs_formulaire', 'inc');
735                $champs = $chercher_champs(null, 'inscription');
736                foreach ($champs as $valeur) {
737                        $valeurs[$valeur] = _request($valeur);
738                        if (is_array($valeurs[$valeur])) {
739                                $valeurs[$valeur] = implode(',', $valeurs[$valeur]);
740                        }
741
742                        $valeurs[$valeur] = trim($valeurs[$valeur]);
743                        if ($valeur == 'naissance') {
744                                $annee = trim(_request('naissance_annee'));
745                                $mois = _request('naissance_mois');
746                                $jour = _request('naissance_jour');
747                                $valeurs[$valeur] = sql_format_date($annee, $mois, $jour);
748                                if ($valeurs[$valeur] == '0000-00-00') {
749                                        unset($valeurs[$valeur]);
750                                        set_request($valeur, '');
751                                }
752                        }
753                }
754                // Definir le login s'il a besoin de l'etre
755                // NOM et LOGIN sont des champs obligatoires donc a la creation il ne doivent pas etre vide
756                // Apres on s'en fiche s'il n'est pas dans le formulaire
757                if (!$valeurs['login'] and !$nom) {
758                        if ($valeurs['nom_famille'] or $valeurs['prenom']) {
759                                $valeurs['nom'] = trim($valeurs['prenom'].' '.$valeurs['nom_famille']);
760                        } else {
761                                $valeurs['nom'] = strtolower(translitteration(preg_replace('/@.*/', '', $mail)));
762                        }
763                } else {
764                        $valeurs['nom'] = $nom;
765                }
766
767                $valeurs['email'] = $mail;
768                if (!$valeurs['login']) {
769                        if ($user['login']) {
770                                $valeurs['login'] = $user['login'];
771                        }
772                }
773
774                $trouver_table = charger_fonction('trouver_table', 'base');
775
776                //genere le tableau des valeurs a mettre a jour pour spip_auteurs
777                //toutes les clefs qu'inscription3 peut mettre a jour
778                $clefs = $trouver_table('auteurs');
779                $clefs = $clefs['field'];
780
781                //extrait uniquement les donnees qui ont ete proposees a la modification
782                $val = array_intersect_key($valeurs, $clefs);
783
784                /**
785                 * Si on demande le pass dans le formulaire
786                 * Le compte est automatiquement activé
787                 */
788                if ($mode == 'inscription_pass') {
789                        if (strlen(_request('password')) != 0) {
790                                $new_pass = _request('password');
791                        } elseif ($mode == 'inscription_pass') {
792                                $new_pass = _request('pass');
793                        }
794
795                        if (strlen($new_pass)>0) {
796                                include_spip('inc/acces');
797                                include_spip('auth/sha256.inc');
798                                $val['htpass'] = generer_htpass($new_pass);
799                                $val['alea_actuel']  = creer_uniqid();
800                                $val['alea_futur'] = creer_uniqid();
801                                $val['pass'] = _nano_sha256($val['alea_actuel'].$new_pass);
802                                $val['low_sec'] = '';
803                        }
804                        $val['statut'] = (strlen($flux['args']['args'][0]) > 1) ?
805                                $flux['args']['args'][0] : ($config_i3['statut_nouveau'] ?
806                                        $config_i3['statut_nouveau'] : '6forum');
807                }
808
809                /**
810                 * On met le compte en "à confirmer" si on a configuré les choses comme cela
811                 * Dans ce cas on met la bio à '' si elle n'est pas dans le form afin d'enlever le statut temporaire
812                 * qui y est stocké par SPIP
813                 * Sinon si on a la bio dans le formulaire et qu'on la reçoit, on met directement un statut à
814                 * l'auteur, sinon on laisse l'ancien (nouveau normalement)
815                 */
816                if ($config_i3['valider_comptes'] == 'on') {
817                        $mode = 'aconfirmer';
818                        if (!$val['bio']) {
819                                $val['bio'] = '';
820                        }
821                        $val['statut'] = '8aconfirmer';
822                } elseif (_request('bio')) {
823                        /**
824                         * Si on a le champ bio dans le formulaire on force le statut
825                         */
826                        $val['statut'] = (strlen($flux['args']['args'][0]) > 1) ?
827                                $flux['args']['args'][0] : ($config_i3['statut_nouveau'] ?
828                                        $config_i3['statut_nouveau'] : '6forum');
829                }
830
831                if (strlen($val['pass']) == 0) {
832                        unset($val['pass']);
833                }
834
835                if (function_exists('test_inscription')) {
836                        $f = 'test_inscription';
837                } else {
838                        $f = 'test_inscription_dist';
839                }
840
841                $desc = $f($user['bio'], $mail, $valeurs['nom'], $user['id_auteur']);
842
843                if (is_array($desc) and $mail = $desc['email']) {
844                        /**
845                         * On recrée le pass pour être sûr d'avoir le bon
846                         */
847                        $desc['pass'] = creer_pass_pour_auteur($user['id_auteur']);
848                        $desc['login'] = $val['login'];
849
850                        /**
851                         * Mise à jour des infos
852                         */
853                        sql_updateq(
854                                'spip_auteurs',
855                                $val,
856                                'id_auteur = '.$user['id_auteur']
857                        );
858
859                        $args = array_merge(
860                                $flux['args'],
861                                array(
862                                        'id_auteur' => $user['id_auteur'],
863                                        'champs' => $valeurs
864                                )
865                        );
866
867                        /**
868                         * Prise en charge du logo
869                         */
870                        if (isset($_FILES['logo']) and ($_FILES['logo']['error'] == 0)) {
871                                $chercher_logo = charger_fonction('chercher_logo', 'inc');
872
873                                // supprimer l'ancien logo
874                                if ($on = $chercher_logo($id_auteur, 'id_auteur', 'on')) {
875                                        spip_unlink($on[0]);
876                                }
877
878                                include_spip('formulaires/editer_logo');
879                                include_spip('action/editer_logo');
880                                $sources = formulaire_editer_logo_get_sources();
881                                foreach ($sources as $etat => $file) {
882                                        if ($file and $file['error'] == 0) {
883                                                logo_modifier('auteur', $user['id_auteur'], $etat, $file);
884                                                set_request('logo_up', ' ');
885                                        }
886                                }
887                                // indiquer qu'on doit recalculer les images
888                                $GLOBALS['var_images'] = true;
889                        }
890                        /**
891                         * On appelle le pipeline traiter de inscription3
892                         * On connait dorénavant l'id_auteur
893                         * Ce pipeline doit retourner un array avec les valeurs possibles suivantes :
894                         * - ne_pas_confirmer_par_mail boolean (permet de squeezer la notification)
895                         * - message_ok string (permet de modifier le message de retour du formulaire)
896                         * - editable boolean (permet de modifier le comportement d'affichage au retour)
897                         */
898                        $traiter_plugin = pipeline(
899                                'i3_traiter_formulaire',
900                                array(
901                                        'args' => $args,
902                                        'data' => $flux['data']
903                                )
904                        );
905                        if (!$traiter_plugin['ne_pas_confirmer_par_mail']) {
906                                if ($mode == 'aconfirmer') {
907                                        $traiter_plugin['message_ok'] = _T('inscription3:form_retour_aconfirmer');
908                                        if ($notifications = charger_fonction('notifications', 'inc')) {
909                                                $notifications('i3_inscriptionauteur', $user['id_auteur'],
910                                                        array('statut' => '8aconfirmer')
911                                                );
912                                        }
913                                } elseif ($mode == 'inscription_pass') {
914                                        $traiter_plugin['message_ok'] = _T('inscription3:form_retour_inscription_pass');
915                                        if ($notifications = charger_fonction('notifications', 'inc')) {
916                                                $notifications('i3_inscriptionauteur', $user['id_auteur'],
917                                                        array('statut' => $val['statut'],'pass' => 'ok')
918                                                );
919                                        }
920                                        if ($config_i3['auto_login'] == 'on') {
921                                                $auteur = sql_fetsel('*', 'spip_auteurs', 'id_auteur='.intval($user['id_auteur']));
922                                                include_spip('inc/auth');
923                                                auth_loger($auteur);
924                                                $traiter_plugin['message_ok'] = _T('inscription3:form_retour_inscription_pass_logue');
925                                        }
926                                } else {
927                                        $envoyer_mail = charger_fonction('envoyer_mail', 'inc');
928                                        if (function_exists('envoyer_inscription3')) {
929                                                $mode = $config_i3['statut_nouveau'];
930                                                $f = 'envoyer_inscription3';
931                                                list($sujet,$msg,$from,$head) = $f($desc, $nom, $mode);
932                                        }
933                                        if ($desc) {
934                                                if (!$envoyer_mail($mail, $sujet, $msg, $from, $head)) {
935                                                        $traiter_plugin['message_ok'] = _T('form_forum_probleme_mail');
936                                                } else {
937                                                        $traiter_plugin['message_ok'] = _T('form_forum_identifiant_mail');
938                                                }
939                                        } else {
940                                                $traiter_plugin['message_ok'] = _T('form_forum_identifiant_mail');
941                                        }
942                                }
943                        }
944                        $flux['data']['editable'] = $traiter_plugin['editable'];
945                        $flux['data']['message_ok'] = $traiter_plugin['message_ok'];
946                        $flux['data']['redirect'] = $traiter_plugin['redirect'];
947                }
948        }
949        return $flux;
950}
951
952/**
953 * Insertion dans le pipeline recuperer_fond (SPIP)
954 * Insère des champs dans le formulaire d'inscription
955 * Ajoute un vérificateur de complexité de mot de passe sur les formulaires de mot de passe
956 * et d'édition d'auteur si besoin
957 *
958 * @param array $flux
959 * @return array
960 */
961function inscription3_recuperer_fond($flux) {
962        $forms = array(
963                'formulaires/inscription',
964                'formulaires/login',
965                'formulaires/mot_de_passe',
966                'formulaires/editer_auteur'
967        );
968        if (in_array($flux['args']['fond'], $forms)) {
969                if (!function_exists('lire_config')) {
970                        include_spip('inc/config');
971                }
972                $config = lire_config('inscription3', array());
973                if ($flux['args']['fond']=='formulaires/inscription') {
974                        $insc = recuperer_fond('formulaires/inc-inscription-inscription3', $flux['data']['contexte']);
975                        $flux['data']['texte'] = preg_replace(
976                                "/(<(li|div) [^>]*class=[\"']editer saisie_mail_inscription.*<\/(li|div)>)/Uims",
977                                "\\1". $insc,
978                                $flux['data']['texte'],
979                                1
980                        );
981                        if (($texte_inscription = $config['inscription_texte']) and ($texte_inscription != 'origine')) {
982                                switch ($texte_inscription) {
983                                        case 'aucun':
984                                                $flux['data']['texte'] = preg_replace(
985                                                        "/<p [^>]*class=[\"']explication.*<\/p>/Uims",
986                                                        '',
987                                                        $flux['data']['texte'],
988                                                        1
989                                                );
990                                                break;
991                                        case 'libre':
992                                                $texte = PtoBR(propre($config['inscription_texte_libre']));
993                                                $flux['data']['texte'] = preg_replace(
994                                                        "/(<p class=[\"']explication mode[\"']>)(.*)(<\/p>)/Uims",
995                                                        "\\1".$texte."\\3",
996                                                        $flux['data']['texte'],
997                                                        1
998                                                );
999                                                break;
1000                                }
1001                        }
1002                }
1003                if ($flux['args']['fond']=='formulaires/login') {
1004                        if (isset($config['affordance_form'])
1005                                and ($type_affordance = $config['affordance_form'])
1006                                and ($type_affordance != 'login')) {
1007                                switch ($type_affordance) {
1008                                        case 'email':
1009                                                $label = _T('inscription3:votre_mail');
1010                                                break;
1011                                        case 'login_et_email':
1012                                                $label = _T('inscription3:votre_login_mail');
1013                                                break;
1014                                        case 'libre':
1015                                                $label = $config['inscription3/affordance_form_libre'] ?
1016                                                        $config['inscription3/affordance_form_libre'] : _T('login_login2');
1017                                                break;
1018                                }
1019                                if ($label) {
1020                                        $flux['data']['texte'] = preg_replace(
1021                                                '/(<label.*for="var_login">)(.*)(<\/label>)/Uims',
1022                                                "\\1".$label."\\3",
1023                                                $flux['data']['texte'],
1024                                                1
1025                                        );
1026                                }
1027                        }
1028                }
1029                /**
1030                 * On ajoute un vérificateur de complexité de mot de passe
1031                 */
1032                if (
1033                        isset($config['inscription3/password_complexite'])
1034                        and $config['inscription3/password_complexite'] == 'on'
1035                        and in_array($flux['args']['fond'], array('formulaires/mot_de_passe','formulaires/editer_auteur'))) {
1036                        $js = recuperer_fond('formulaires/inc-js_pass_verification', $flux['data']['contexte']);
1037                        $flux['data']['texte'] = preg_replace('/(<\/form>)(.*)/Uims', "\\1".$js."\\2", $flux['data']['texte'], 1);
1038                }
1039        }
1040        return $flux;
1041}
1042
1043/**
1044 * Insertion dans le pipeline editer_contenu_objet (SPIP)
1045 * Enlève les champs dans le formulaire d'édition d'auteur pour le profil utilisateur
1046 * comme il est configuré dans inscription3
1047 *
1048 * @param array $flux
1049 * @return array
1050 */
1051function inscription3_editer_contenu_objet($flux) {
1052        $args = $flux['args'];
1053        $type = $args['type'];
1054        if ($type == 'auteur' and intval($args['id']) > 0 and !test_espace_prive()) {
1055                if (!function_exists('lire_config')) {
1056                        include_spip('inc/config');
1057                }
1058                $config = lire_config('inscription3', array());
1059                $champs_spip = array('nom','email','bio','pgp','url_site','nom_site','login','pass');
1060                $champs_vires = array();
1061                $inserer_saisie = '';
1062                foreach ($champs_spip as $champ) {
1063                        if (isset($config[$champ.'_fiche_mod']) and $config[$champ.'_fiche_mod'] != 'on') {
1064                                if ($champ == 'login') {
1065                                        $flux['data'] = preg_replace(
1066                                                "/(<(li|div) [^>]*class=[\"']editer editer_new_($champ).*<\/(li|div)>)/Uims",
1067                                                '',
1068                                                $flux['data'],
1069                                                1
1070                                        );
1071                                } elseif ($champ == 'pass') {
1072                                        $flux['data'] = preg_replace(
1073                                                "/(<(li|div) [^>]*class=[\"']editer editer_new_($champ).*<\/(li|div)>)/Uims",
1074                                                '',
1075                                                $flux['data'],
1076                                                1
1077                                        );
1078                                        $flux['data'] = preg_replace(
1079                                                "/(<(li|div) [^>]*class=[\"']editer editer_new_($champ)2.*<\/(li|div)>)/Uims",
1080                                                '',
1081                                                $flux['data'],
1082                                                1
1083                                        );
1084                                } else {
1085                                        $flux['data'] = preg_replace(
1086                                                "/(<(li|div) [^>]*class=[\"']editer editer_($champ).*<\/(li|div)>)/Uims",
1087                                                '',
1088                                                $flux['data'],
1089                                                1
1090                                        );
1091                                }
1092                                $champs_vires[] = $champ;
1093                                if (in_array($champ, array('nom','email'))) {
1094                                        $inserer_saisie .= "<input type='hidden' name='$champ' value='".$flux['args']['contexte'][$champ]."' />\n";
1095                                }
1096                        }
1097                }
1098
1099                /**
1100                 * On vire le champs création du formulaire (ne doit pas être modifié manuellement)
1101                 * Si on n'a pas ce champs rempli, on utilise la date actuelle pour le remplir
1102                 * Logiquement ce champs est rempli automatiquement via pre_insertion pour tous les auteurs
1103                 */
1104                if (isset($config['creation']) and $config['creation'] == 'on') {
1105                        $flux['data'] = preg_replace(
1106                                inscription3_regexp_capturer_balise('class', 'editer editer_creation', true),
1107                                '',
1108                                $flux['data'],
1109                                1
1110                        );
1111                        spip_log(inscription3_regexp_capturer_balise('class', 'editer editer_cextra_creation', true), 'test.'._LOG_ERREUR);
1112                        $flux['data'] = preg_replace(
1113                                inscription3_regexp_capturer_balise('class', 'editer editer_cextra_creation', true),
1114                                '',
1115                                $flux['data'],
1116                                1
1117                        );
1118
1119                        if ($flux['args']['contexte']['creation'] == '0000-00-00 00:00:00') {
1120                                $flux['args']['contexte']['creation'] = date('Y-m-d H:i:s');
1121                        }
1122                        $inserer_saisie .= "<input type='hidden' name='creation' value='".$flux['args']['contexte']['creation']."' />\n";
1123                }
1124
1125                if (!test_espace_prive() and isset($config['logo_fiche_mod']) and $config['logo_fiche_mod'] == 'on') {
1126                        $flux['data'] = preg_replace(
1127                                '/<(form.*[^>])>/Uims',
1128                                '<\\1 enctype=\'multipart/form-data\'>',
1129                                $flux['data'],
1130                                1
1131                        );
1132                        $saisie_logo = recuperer_fond('formulaires/inscription_logo', $flux['args']['contexte']);
1133                        $flux['data'] = preg_replace(
1134                                '/(<!--extra-->)/is',
1135                                '<ul class="champs_extras inscription_logo">'.$saisie_logo.'</ul>'."\n".'$1',
1136                                $flux['data']
1137                        );
1138                }
1139                if (in_array('url_site', $champs_vires) and in_array('nom_site', $champs_vires)) {
1140                        $flux['data'] = preg_replace(
1141                                "/(<(li|div) [^>]*class=[\"']editer_liens.*<\/(li|div)>)/Uims",
1142                                '',
1143                                $flux['data'],
1144                                1
1145                        );
1146                }
1147                if (in_array('pass', $champs_vires) and in_array('login', $champs_vires)) {
1148                        $flux['data'] = preg_replace(
1149                                "/(<(li|div) [^>]*class=[\"']editer_identification.*<\/(li|div)>)/Uims",
1150                                '',
1151                                $flux['data'],
1152                                1
1153                        );
1154                }
1155                if (strlen($inserer_saisie)) {
1156                        $flux['data'] = preg_replace('/(<!-- controles md5 -->)/is', $inserer_saisie."\n".'$1', $flux['data']);
1157                }
1158        }
1159        return $flux;
1160}
1161
1162
1163/**
1164 * Retourne une expression régulière complexe de capture d'une balise spécifique
1165 * ayant un attribut à une certaine valeur.
1166 *
1167 * Cette balise (une div par défaut) au milieu d'un code HTML peut contenir
1168 * d'autres balises à l'intérieur.
1169 *
1170 * @example `inscription3_regexp_capturer_balise('id', 'content')
1171 * @example `inscription3_regexp_capturer_balise('class', 'editer editer_truc', true)
1172 *
1173 * @link http://mac-blog.org.ua/regex-for-div-and-it-content/ pour l'inspiration
1174 * @link http://php.net/manual/fr/regexp.reference.recursive.php#95568
1175 *
1176 * @note
1177 *     Les expressions régulières ne sont pas adaptées pour traiter du html…
1178 *     Mais on tente un miracle.
1179 * @note
1180 *     Mélange adapté entre 3 expressions :
1181 *     ```
1182 *     ",(<div [^>]*class=[\"']editer editer_creation.*<\/div>),Uims"
1183 *     '#<div\s+class="s"[^>]*>((?:(?:(?!<div[^>]*>|</div>).)+|<div[^>]*>[\s\S]*?</div>)*)</div>#six'
1184 *     "/<([\w]+)([^>]*?)(([\s]*\/>)|" . "(>((([^<]*?|<\!\-\-.*?\-\->)|(?R))*)<\/\\1[\s]*>))/sm";
1185 *     ```
1186 *
1187 * @param string $attr
1188 *     Attribut à chercher (exemple: class)
1189 * @param string $valeur
1190 *     Valeur à chercher (exemple: editer editer_truc)
1191 * @param bool $flou
1192 *     True si l'attribut peut avoir d'autres éléments avant ou après la valeur cherchée
1193 * @param string $balise
1194 *     La balise qu'on recherche
1195 * @param string $modificateurs
1196 *     Modificateurs de l'expression (pas de modificateur U qui provoquerait un echec).
1197 * @return string Expression régulière
1198**/
1199function inscription3_regexp_capturer_balise($attr, $valeur, $flou = false, $balise = 'div', $modificateurs = 'ims') {
1200        $regexp =
1201                # une balise indiquée avec un attribut ouvrant avec soit " ou ' (info capturée en \1)
1202                '#<' . $balise . ' [^>]*' . $attr . '=(["\'])'
1203                # la valeur cherchée, avec ou sans flou autour
1204                . ($flou ? '(?:(?!\1).)*' . $valeur . '(?:(?!\1).)*': $valeur)
1205                # la fin de guillement de l'attribut trouvé
1206                . '\1'
1207                # juste à la fin de la div ouvrante trouvée
1208                . '[^>]*>'
1209                # autant de couples de balises (dont autofermantes) et commentaires qu'on veut
1210                        // des balises imbriquées ou non
1211                        . '(?<balises>('
1212                                // pas de début de balise
1213                                . '([^<]*?)('
1214                                        // une balise qui s'ouvre
1215                                        . '<(?<tag>[\w]+)([^>]*?)'
1216                                        // et soit
1217                                        . '('
1218                                                // 'une balise autofermante'
1219                                                . '([\s]*\/>)'
1220                                                // 'une fermeture de balise et soit
1221                                                . '|(>(('
1222                                                        . '('
1223                                                                // pas de balise ouvrante
1224                                                                . '[^<]*?'
1225                                                                // ou commentaire html
1226                                                                . '|<\!\-\-.*?\-\->'
1227                                                                // ou script html
1228                                                                . '|<script[^>]*>.*?<\/script>'
1229                                                        .')'
1230                                                        // ou recursion sur balise
1231                                                        . '|(?&balises)'
1232                                                // 0 ou plusieurs fois
1233                                                . ')*)'
1234                                                // et la fin de la balise
1235                                                . '<\/(?&tag)[\s]*>)'
1236                                        . ')'
1237                                . ')'
1238                        . ')*)'
1239                        // pas de début de balise
1240                        . '([^<]*?)'
1241                # la fin de notre balise
1242                . '</' . $balise . '>'
1243                # les modificateurs
1244                . '#' . $modificateurs;
1245
1246        return $regexp;
1247}
1248
1249/**
1250 * Insertion dans le pipeline "notifications_destinataires" (SPIP)
1251 *
1252 * En fonction du type de notification, rempli un tableau d'adresses emails
1253 *
1254 * @param array $flux Le contexte du pipeline
1255 * @return array
1256 */
1257function inscription3_notifications_destinataires($flux) {
1258        $quoi = $flux['args']['quoi'];
1259        $options = $flux['args']['options'];
1260
1261        /**
1262         * Cas de la validation ou invalidation d'un compte d'un utilisateur
1263         * Cas également de l'inscription d'un auteur
1264         * Envoi à l'utilisateur ($options['type'] == 'user')
1265         */
1266        if (($quoi=='instituerauteur' and $options['statut_ancien'] == '8aconfirmer' and $options['type'] == 'user')
1267                or ($quoi=='i3_inscriptionauteur' and $options['type'] == 'user')) {
1268                $id_auteur = $flux['args']['id'];
1269                include_spip('base/abstract_sql');
1270                $mail = sql_getfetsel('email', 'spip_auteurs', 'id_auteur='.intval($id_auteur));
1271                $flux['data'][] = $mail;
1272        } elseif (($quoi=='instituerauteur' and $options['statut_ancien'] == '8aconfirmer'
1273                and $options['type'] == 'admin')
1274                or ($quoi=='i3_inscriptionauteur' and $options['type'] == 'admin')) {
1275                        /**
1276                         * Cas de la validation ou invalidation d'un compte d'un utilisateur
1277                         * Envoi aux administrateurs ($options['type'] == 'admin')
1278                         */
1279                        /**
1280                         * Aller chercher dans la conf les admins à notifier si configuré
1281                         */
1282                        if (is_array(lire_config('inscription3/admin_notifications'))) {
1283                                $id_admins = lire_config('inscription3/admin_notifications');
1284                                $admins = sql_allfetsel(
1285                                        'email',
1286                                        'spip_auteurs',
1287                                        'statut="0minirezo" and ' . sql_in('id_auteur', $id_admins)
1288                                );
1289                        } else {
1290                                $admins = sql_allfetsel('email', 'spip_auteurs', 'statut="0minirezo" and webmestre="oui"');
1291                        }
1292
1293                foreach ($admins as $qui) {
1294                        $flux['data'][] = $qui['email'];
1295                }
1296        }
1297        return $flux;
1298}
1299
1300/**
1301 * Insertion dans le pipeline taches_generales_cron (SPIP)
1302 *
1303 * Vérifie la présence à intervalle régulier d'utilisateurs à valider ou invalider et notifie les admins
1304 *
1305 * @param array $taches_generales Un array des tâches du cron de SPIP
1306 * @return L'array des taches complété
1307 */
1308function inscription3_taches_generales_cron($taches_generales) {
1309        $taches_generales['inscription3_taches_generales'] = 24*60*60;
1310        return $taches_generales;
1311}
1312
1313/**
1314 * Insertion dans le pipeline pre_insertion (SPIP)
1315 *
1316 * Insérer la date d'inscription à la création de l'auteur
1317 * - la date d'inscription ne se met qu'à ce moment là
1318 *
1319 * @param array $flux Le contexte du pipeline
1320 * @return array
1321 */
1322function inscription3_pre_insertion($flux) {
1323        include_spip('inc/config');
1324        if (lire_config('inscription3/creation') == 'on' and $flux['args']['table'] == 'spip_auteurs') {
1325                $flux['data']['creation'] = date('Y-m-d H:i:s');
1326        }
1327        return $flux;
1328}
1329
1330/**
1331 * Insertion dans le pipeline openid_recuperer_identite (OpenID)
1332 * On décrypte les informations fournies par OpenID pour les insérer dans notre formulaire
1333 *
1334 * @param $flux array
1335 *      Le contexte du pipeline
1336 *      Les informations fournies par le compte openid de la personne souhaitant s'inscrire sont dans $flux['args']
1337 * @return $flux
1338 *      Le contexte du pipeline décrypté, on place dans $flux['data'] les informations qui nous intéresse
1339 */
1340function inscription3_openid_recuperer_identite($flux) {
1341        if (isset($flux['args']['dob'])) {
1342                $flux['data']['naissance'] = $flux['args']['dob'];
1343        }
1344
1345        if (isset($flux['args']['country'])) {
1346                $id_pays = sql_getfetsel('id_pays', 'spip_geo_pays', 'code_iso='.sql_quote($flux['args']['country']));
1347                $flux['data']['pays'] = $id_pays;
1348        }
1349        if (isset($flux['args']['postcode'])) {
1350                $flux['data']['code_postal'] = $flux['args']['postcode'];
1351        }
1352
1353        if (isset($flux['args']['gender'])) {
1354                $flux['data']['sexe'] = $flux['args']['gender'];
1355        }
1356
1357        if (isset($flux['args']['fullname'])) {
1358                $noms = explode(' ', $flux['args']['fullname']);
1359                $flux['data']['prenom'] = $noms[0];
1360                array_shift($noms);
1361                $flux['data']['nom_famille'] = implode(' ', $noms);
1362        }
1363        return $flux;
1364}
1365
1366/**
1367 * Insertion dans le pipeline openid_inscrire_redirect (OpenID)
1368 */
1369function inscription3_openid_inscrire_redirect($flux) {
1370
1371        $auteur = $flux['args']['infos_auteur'];
1372
1373        $url = $flux['args']['url'];
1374
1375        $url = parametre_url($url, 'code_postal', $auteur['code_postal']);
1376        $url = parametre_url($url, 'pays', $auteur['pays']);
1377        $url = parametre_url($url, 'naissance', $auteur['naissance']);
1378        $url = parametre_url($url, 'sexe', $auteur['sexe']);
1379        $url = parametre_url($url, 'login', $auteur['login']);
1380        $url = parametre_url($url, 'nom_famille', $auteur['nom_famille']);
1381        $url = parametre_url($url, 'prenom', $auteur['prenom']);
1382        $flux['data'] = $url;
1383        return $flux;
1384}
1385
1386/**
1387 * Insertion dans le pipeline post_edition (SPIP)
1388 *
1389 * Notifier les admins et les users quand ils passent de 8aconfirmer à un statut valide
1390 *
1391 * @param array $flux
1392 *              Le contexte du pipeline
1393 * @return array $flux
1394 *              Le contexte du pipeline modifié
1395 */
1396function inscription3_post_edition($flux) {
1397        if (isset($flux['args']['action'])
1398                and $flux['args']['action'] == 'instituer'
1399                and $flux['args']['table'] == 'spip_auteurs'
1400                and $flux['args']['statut_ancien'] == '8aconfirmer') {
1401                if ($notifications = charger_fonction('notifications', 'inc')) {
1402                        $notifications('i3_inscriptionauteur', $flux['args']['id_objet'],
1403                                array('statut_ancien' => '8aconfirmer', 'statut_nouveau' => $flux['data']['statut'])
1404                        );
1405                }
1406        }
1407        return $flux;
1408}
Note: See TracBrowser for help on using the repository browser.