source: spip-zone/_plugins_/spip-listes/spip-listes_1_9_3/inc/spiplistes_import.php @ 50485

Last change on this file since 50485 was 50485, checked in by paladin@…, 8 years ago

petit todo

  • Property svn:eol-style set to LF
  • Property svn:keywords set to LastChangedBy LastChangedDate LastChangedRevision
File size: 14.5 KB
Line 
1<?php
2/**
3 * @version From SPIP-Listes-V :: import_export.php,v 1.19 paladin@quesaco.org  http://www.quesaco.org/
4 * @package spiplistes
5 *
6 *
7 *
8 * @todo CP-20110815: lors de la création d'un compte, le format de réception
9 * n'est appliqué qu'à la (les) liste sélectionnée. Appliquer
10 * ce format au profil par défaut (spip_auteurs_elargis.spip_listes_format)
11 * Vérifier ce format lors d'une modification
12 * de compte et appliquer ce profil par défaut si manquant.
13 *
14 */
15 // $LastChangedRevision: 50485 $
16 // $LastChangedBy: paladin@quesaco.org $
17 // $LastChangedDate: 2011-08-15 16:40:37 +0000 (Mon, 15 Aug 2011) $
18
19if (!defined('_ECRIRE_INC_VERSION')) return;
20
21include_spip('inc/presentation');
22include_spip('inc/acces');
23include_spip('inc/spiplistes_api_globales');
24
25/**
26 * Import d'un fichier texte, liste d'abonnes
27 *
28 * Le fichier doit etre de type CVS.
29 * Les enregistrements sont separes par une tabulation
30 * ou un point-virgule ';'
31 * Exemple:
32 * me@example.com;mylogin;My Name;0minirezo
33 *
34 * @param string $filename
35 * @param string $realname
36 * @param array $abos_liste
37 * @param string $format_abo
38 * @param string $separateur
39 * @param bool $flag_admin pas utilise'!
40 * @param bool $listes_autorisees pas utilise'!
41 * @param bool $forcer_abo
42 * @return string
43 * @todo code a nettoyer
44 */
45function spiplistes_import (
46        $filename
47        , $realname
48        , $abos_liste
49        , $format_abo = 'non'
50        , $separateur = "\t"
51        , $flag_admin
52        , $listes_autorisees
53        , $forcer_abo = false
54) {
55
56        $result_affiche = '';
57
58        if (is_readable($filename)
59           && ($abos_liste = (spiplistes_ids_valides ($abos_liste))))
60        {
61                // pour les stats
62                $compteur = array(
63                        'creer' => 0
64                        , 'abonner' => 0
65                        , 'existe' => 0
66                        , 'format' => 0
67                );
68                $bad_dupli = $bad_email = 0;
69                $statuts_auteurs = array('6forum', '1comite', '0minirezo');
70               
71                $stack_new_auteurs = array(); // tableau des comptes à créer
72               
73                $stack_new_abonnes = array(); // Tableau des comptes à abonner
74               
75                $nb_fiches_import = 0; // nb de lignes valides dans le fichier
76               
77                $nb_auteurs_exists = 0; // comptes déjà dans la base
78               
79                $nb_abos_records = 0; // nb abonnements enregistrés
80               
81                $start_time = microtime(1);
82               
83                /**
84                 * En cas d'import de comptes existants,
85                 * préserver le statut de chaque compte.
86                 * Le compte par défaut reçoit un statut temporaire
87                 * pour mise à jour par paquet.
88                 * Voir plus bas pour info.
89                 */
90                $tmp_statut = date('YmdGis'); // statut temporaire
91                $s = '6forum';
92                $current_statuts = array($s => $s.$tmp_statut);
93               
94                /**
95                 * Recupere les logins et mails existants dans la base
96                 * pour eviter les doublons.
97                 * Les comptes sans mail sont ignorés.
98                 * Le résulat est un tableau :
99                 * (
100                 *      email => array (id_auteur, format, statut),
101                 *      ...
102                 * )
103                 */
104                $current_auteurs = spiplistes_auteurs_par_mail ();
105               
106                /**
107                 * Charger la table des abonnements en ram
108                 * afin d'eviter les petites requettes.
109                 */
110                $current_abonnements = spiplistes_abonnements_lister ();
111               
112                /**
113                 * Import du fichier transmis
114                 */
115                spiplistes_log('IMPORT FILE: '.$realname);
116
117                $contenu_fichier = file($filename);
118               
119                //spiplistes_debug_log ('memory_get_usage[3]: ' . memory_get_usage());
120               
121                $nb_lignes_fichier = count($contenu_fichier);
122               
123                //spiplistes_debug_log ('memory_get_usage[2]: ' . memory_get_usage());
124                //spiplistes_debug_log ('memory_get_peak_usage[2]: ' . memory_get_peak_usage());
125               
126                for($jj = 0; $jj < $nb_lignes_fichier; $jj++)
127                {
128                        $nouvelle_entree = trim($contenu_fichier[$jj]);
129                       
130                        if(!empty($nouvelle_entree)
131                           // ni une ligne de commentaire
132                           && (
133                                   ($char = substr($nouvelle_entree, 0, 1))
134                                   && ($char != '#')
135                                   && ($char != '/')
136                                )
137                        ) {
138                                $nb_fiches_import++;
139                               
140                                list($email, $login, $nom) = explode($separateur, $nouvelle_entree);
141                               
142                                $email = strtolower(trim($email));
143
144                                $mail_exist = FALSE;
145                               
146                                $email = email_valide($email);
147                               
148                                if ($email
149                                   &&   (
150                                                !($mail_exist = array_key_exists($email, $current_auteurs))
151                                                || $forcer_abo
152                                                )
153                                )
154                                {
155                                       
156                                        /**
157                                         * Si le compte n'existe pas, le creer
158                                         */
159                                        if(!$mail_exist)
160                                        {
161                                                /**
162                                                 * Commencer par calculer le login
163                                                 */
164                                                $login = trim($login);
165                                                if(empty($login))
166                                                {
167                                                        $login = spiplistes_login_from_email($email);
168                                                }
169                                                else
170                                                {
171                                                        $login = strtolower($login);
172                                                }
173                                               
174                                                /**
175                                                 * puis le nom
176                                                 */
177                                                $nom = trim($nom);
178                                                if(empty($nom))
179                                                {
180                                                        $nom = ucfirst($login);
181                                                }
182                                               
183                                                /**
184                                                 * Ajoute l'invité dans la table des auteurs
185                                                 */
186                                                $pass = creer_pass_aleatoire(8, $email);
187                                       
188                                                /**
189                                                 * Nouvel abo dans la pile des "a creer"
190                                                 */
191                                                $stack_new_auteurs[] = array(
192                                                        'nom' => $nom
193                                                        , 'email' => $email
194                                                        , 'login' => $login
195                                                        , 'pass' => md5($pass)
196                                                        , 'statut' => $current_statuts['6forum']
197                                                        , 'htpass' => generer_htpass($pass)
198                                                );
199                                        } // end if(!$mail_exist)
200                                       
201                                        // adresse mail existe dans la base
202                                        // si on passe par ici, c'est sous-entendu $forcer_abo
203                                        // (doit abonner un compte existant)
204                                        else
205                                        {
206                                                $nb_auteurs_exists++;
207                                                $stack_new_abonnes[] = intval($current_auteurs[$email]['id_auteur']);
208                                        }
209                                }
210                               
211                                /**
212                                 * Signale en log si la ligne lue est erronée.
213                                 */
214                                if (!$email) {
215                                        spiplistes_log ('BAD ENTRY @ LINE #'.$jj.': '.$nouvelle_entree);
216                                }
217                        }
218                } // end for
219                               
220                $creer_comptes = count($stack_new_auteurs);
221                spiplistes_debug_log ('CREATE '.$creer_comptes.' new accounts');
222               
223                $nb_inscrire_abos = count($stack_new_abonnes);
224                spiplistes_debug_log ('SUBSCRIBE '
225                                                          . ($creer_comptes + $nb_inscrire_abos)
226                                                          . ' accounts');
227               
228                /**
229                 * Préparer les statuts temporaires :
230                 * On reprend les statuts existants dans la table des
231                 * auteurs
232                 */
233                foreach ($current_auteurs as $key => $val)
234                {
235                        $s = $val['statut'];
236                        if (!isset ($current_statuts[$s])) {
237                                $current_statuts[$s] = NULL;
238                        }
239                        //spiplistes_debug_log ($s);
240                }
241                /**
242                 * Les statuts temporaires reprennent la clé.
243                 * Permettra de changer (update) le vrai statut plus tard
244                 * par paquets de statuts au lieu de par enregistrement.
245                 */
246                foreach ($current_statuts as $key => $val)
247                {
248                        $current_statuts[$key] = $key.$tmp_statut;
249                }
250               
251                /**
252                 * Appliquer le statut temporaire aux comptes
253                 * existants, pour chaque statut existant.
254                 */
255                $modifier_par_statuts = array();
256                foreach ($current_auteurs as $mail => $auteur)
257                {
258                        if ($format_abo != $auteur['format'])
259                        {
260                                $s = $auteur['statut'];
261                                if (!isset ($modifier_par_statuts[$s])) {
262                                        $modifier_par_statuts[$s] = array();
263                                }
264                                $modifier_par_statuts[$s][] = $auteur['id_auteur'];
265                        }
266                }
267                foreach ($modifier_par_statuts as $s => $ids_auteurs)
268                {
269                        if (count($ids_auteurs))
270                        {
271                                $ids_auteurs = implode(',', $ids_auteurs);
272                               
273                                if (sql_update(array('spip_auteurs')
274                                   , array('statut' => sql_quote($current_statuts[$s]))
275                                   , array('id_auteur IN ('.$ids_auteurs.')')
276                                   ) === FALSE
277                                )
278                                {
279                                        spiplistes_sqlerror_log('stack_format_abo');
280                                }
281                        }
282                }
283               
284                if ($creer_comptes || $nb_inscrire_abos)
285                {
286                        if ($creer_comptes)
287                        {
288                                $sql_col_names = '('.implode(',', array_keys($stack_new_auteurs[0])).')';
289                                $sql_col_values = '';
290                               
291                                //spiplistes_debug_log ('memory_get_usage[5]: ' . memory_get_usage());
292                               
293                                /**
294                                 * Préparer le paquet des comptes à créer
295                                 */
296                                foreach($stack_new_auteurs as $auteur)
297                                {
298                                        $values = array_map('sql_quote', $auteur);
299                                        $sql_col_values .= '('.implode(',', $values).'),';
300                                }
301                                $sql_col_values = rtrim($sql_col_values,',');
302                               
303                                // Envoyer le paquet
304                                if (sql_insert('spip_auteurs', $sql_col_names, $sql_col_values))
305                                {
306                                        /**
307                                         * Récupérer les id_auteur des créés
308                                         * pour ajouter à la table des abonnements
309                                         */
310                                        $sql_select = array('id_auteur');
311                                        $sql_from = array('spip_auteurs');
312                                        $sql_where[] = 'statut='.sql_quote($current_statuts['6forum']);
313                                       
314                                        if ($sql_result = sql_select (
315                                                $sql_select
316                                                , $sql_from
317                                                , $sql_where
318                                                )) {
319                                                while ($row = sql_fetch($sql_result)) {
320                                                        $stack_new_abonnes[] = $row['id_auteur'];
321                                                }
322                                        }
323                                }
324                        }
325                        $nb_inscrire_abos = count($stack_new_abonnes);
326                        spiplistes_debug_log ('SUBCRIBE '.$nb_inscrire_abos.' accounts');
327                       
328                        //spiplistes_debug_log ('memory_get_usage[6]: ' . memory_get_usage());
329                       
330                        /**
331                         * Inscrire les abonnements
332                         */
333                        if ($nb_inscrire_abos) {
334                               
335                                spiplistes_debug_log ('inscription des abos');
336               
337                                $sql_table = 'spip_auteurs_listes';
338                                $sql_update_valeurs = array();
339                                $sql_insert_valeurs = '';
340                                $q_format = sql_quote($format_abo);
341                               
342                                /**
343                                 * Traiter les listes souhaitées une par une
344                                 */
345                                foreach($abos_liste as $id_liste)
346                                {
347                                        $id_liste = intval ($id_liste);
348                                       
349                                        if ($id_liste <= 0) { continue; }
350                                       
351                                        /**
352                                         * Pour les membres déjà inscrits,
353                                         * abonner à la liste si pas déjà abonné
354                                         */
355                                        foreach ($stack_new_abonnes as $id_auteur)
356                                        {
357                                                $deja_abonne = isset($current_abonnements[$id_liste])
358                                                        && in_array($id_auteur, $current_abonnements[$id_liste]);
359                                               
360                                                if (!$deja_abonne)
361                                                {
362                                                        $sql_insert_valeurs .= '('.$id_auteur.','.$id_liste.','.$q_format.',NOW()),';
363                                                        $nb_abos_records++;
364                                                }
365                                                else if ($forcer_abo)
366                                                {
367                                                        if (!isset($sql_update_valeurs[$id_liste]))
368                                                        {
369                                                                $sql_update_valeurs[$id_liste] = array();
370                                                        }
371                                                        $sql_update_valeurs[$id_liste][] = $id_auteur;
372                                                        $nb_abos_records++;
373                                                }
374                                        } // foreach
375                                } // foreach
376                                /**
377                                 * Insertion dans la table des abonnements
378                                 */
379                                if (!empty($sql_insert_valeurs))
380                                {
381                                        $sql_noms = '(id_auteur,id_liste,format,date_inscription)';
382                                        $sql_insert_valeurs = rtrim($sql_insert_valeurs, ',');
383                                       
384                                        if (sql_insert($sql_table, $sql_noms, $sql_insert_valeurs) === FALSE)
385                                        {
386                                                spiplistes_sqlerror_log ('INSERT abonnements');
387                                        }
388                                }
389                                /**
390                                 * Correction de la table des abonnements
391                                 * si forcé.
392                                 */
393                                if (count($sql_update_valeurs))
394                                {
395                                        $desabonner = ($format_abo == 'non');
396                                        $sql_table = 'spip_auteurs_listes';
397                                        $sql_update_champ = array('format' => sql_quote($format_abo));
398                                       
399                                        /**
400                                         * Traiter les listes une par une
401                                         */
402                                        foreach ($sql_update_valeurs as $id_liste => $id_auteurs)
403                                        {
404                                                $sql_where = '
405                                                        id_liste = '.$id_liste . ' AND
406                                                        id_auteur IN (' . implode(',', $id_auteurs) . ')';
407                                               
408                                                /**
409                                                 * Désabonner ?
410                                                 * Supprimer de la liste des abonnements.
411                                                 */
412                                                if ($desabonner)
413                                                {
414                                                        if (sql_delete ($sql_table, $sql_where) === FALSE)
415                                                        {
416                                                                spiplistes_sqlerror_log ('DELETE abonnements');
417                                                        }
418                                                }
419                                                /**
420                                                 * sinon, appliquer le format souhaité
421                                                 */
422                                                else
423                                                {
424                                                        if (sql_update ($sql_table,
425                                                                                        $sql_update_champ,
426                                                                                        $sql_where) === FALSE)
427                                                        {
428                                                                spiplistes_sqlerror_log ('UPDATE format abonnements');
429                                                        }
430                                                }
431                                        }
432                                }
433                        } // if
434               
435                        /**
436                         * Appliquer le format de réception
437                         * @todo A remplacer par la fonction en API
438                         */
439                        if(sql_query(
440                                'INSERT INTO spip_auteurs_elargis
441                                                (id_auteur,`spip_listes_format`) SELECT a.id_auteur,'.sql_quote($format_abo)
442                                                                .' FROM spip_auteurs AS a WHERE a.statut='.sql_quote($tmp_statut))
443                           === FALSE
444                        )
445                        {
446                                spiplistes_sqlerror_log('import: nouveaux formats dans spip_auteurs_elargis');
447                        }
448                }
449               
450               
451                /**
452                 * Redonner le bon statut pour chaque statut rencontré
453                 */
454                foreach ($current_statuts as $key => $val)
455                {
456                        sql_update(array('spip_auteurs')
457                                   , array('statut' => sql_quote($key))
458                                   , array('statut='.sql_quote($val))
459                                   );
460                }
461                // fin des req
462
463                $result_affiche .=
464                        ($tt = ($ii = count($stack_new_auteurs)) + ($jj = count($stack_new_abonnes)))
465                        ?       '<ul>'.PHP_EOL
466                                . '<li class="verdana2">'._T('spiplistes:nb_comptes_importees_en_ms_dont_'
467                                                                                 , array('nb' => $nb_fiches_import
468                                                                                                 , 'ms' => (microtime(1) - $start_time))
469                                                                                 )
470                                . '<ul>'.PHP_EOL
471                                        . '<li>'._T('spiplistes:nb_fiches_crees', array('nb' => $ii)).'</li>'.PHP_EOL
472                                        //. '<li>'._T('spiplistes:nb_comptes_modifies', array('nb' => $jj)).'</li>'.PHP_EOL
473                                        . '<li>'._T('spiplistes:nb_auteurs_exists'
474                                                                , array('nb' => $nb_auteurs_exists)) .'</li>'.PHP_EOL
475                                        . '<li>'._T('spiplistes:nb_abos_enregistres_pour_nb_listes'
476                                                                , array('nb' => $nb_abos_records, 'nl' => count($abos_liste))
477                                                                ).'</li>'.PHP_EOL
478                                       
479                                        //. '<li>'._T('spiplistes:nb_comptes_ignores', array('nb' => $jj)).'</li>'.PHP_EOL
480                                . '</ul>'.PHP_EOL
481                                . '</li>'.PHP_EOL
482                                . '</ul>'.PHP_EOL
483                        : '<br />'._T('spiplistes:pas_dimport').PHP_EOL
484                        ;
485
486                if ($bad_dupli)
487                {
488                        $result_affiche .= '<br />'._T('pass_erreur')
489                                .' email: '._T('spiplistes:n_duplicata_mail', array('n' => $bad_dupli))
490                                .PHP_EOL;
491                }
492                if ($bad_email)
493                {
494                        $result_affiche .= '<br />'._T('pass_erreur')
495                                .' email: '._T('spiplistes:n_incorrect_mail', array('n' => $bad_email))
496                                .PHP_EOL;
497                }
498               
499                $result_affiche = _T('spiplistes:fichier_') . ' : <strong>'.$realname.'</strong><br />'.PHP_EOL
500                        . _T('spiplistes:' . ((count($abos_liste) > 1) ? 'listes_de_destination_s' : 'liste_de_destination_s')
501                                 , array('s' => '#' . implode(',#', $abos_liste))) .'<br />'.PHP_EOL
502                        . $result_affiche
503                        ;
504        }
505        return($result_affiche);
506} // spiplistes_import()
507
508/**
509 * Controler les id donnes
510 *
511 * L'argument est soit un int positif, soit
512 * un tableau d'int positifs.
513 * @param int|array liste à controler
514 * @return array|bool
515 */
516function spiplistes_ids_valides ($ids) {
517       
518        if (!is_array($ids)) {
519                $ids = array ($ids);
520        }
521        if (is_array($ids)) {
522                $array = array();
523                foreach ($ids as $id) {
524                        $ii = intval ($id);
525                        if ($id > 0) {
526                                $array[] = $id;
527                        }
528                }
529                return ($array);
530        }
531        return (FALSE);
532}
533
534/**
535 * Retourne liste des auteurs sous forme
536 * d'un tableau dont l'index est l'email :
537 *      [$email] => array(
538 *              'id_auteur' => $id_auteur,
539 *              'format' => $format,
540 *              'statut' => $statut
541 *              )
542 * @return array
543 */
544function spiplistes_auteurs_par_mail ()
545{
546        $auteurs = array();
547       
548        $auteurs_format = spiplistes_formats_defaut_lister ();
549       
550        if ($sql_result = sql_select(
551                                                          array('id_auteur', 'email', 'statut')
552                                                         , array('spip_auteurs')
553                                                         , array('email<>'.sql_quote(''))
554                                                         )
555        ) {
556                while($row = spip_fetch_array($sql_result))
557                {
558                        $id_auteur = intval($row['id_auteur']);
559                        $email = strtolower($row['email']);
560
561                        $format = (isset($auteurs_format[$id_auteur]))
562                                ? $auteurs_format[$id_auteur]
563                                : 'non'
564                                ;
565                       
566                        $auteurs[$email] = array(
567                                'id_auteur' => $id_auteur,
568                                'format' => $format,
569                                'statut' => $row['statut']
570                                );
571                }
572        }
573        return ($auteurs);
574}
Note: See TracBrowser for help on using the repository browser.