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

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

correction des messages, résultats des imports

  • Property svn:eol-style set to LF
  • Property svn:keywords set to LastChangedBy LastChangedDate LastChangedRevision
File size: 10.2 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 // $LastChangedRevision: 48909 $
7 // $LastChangedBy: paladin@quesaco.org $
8 // $LastChangedDate: 2011-06-18 16:08:13 +0000 (Sat, 18 Jun 2011) $
9
10if (!defined('_ECRIRE_INC_VERSION')) return;
11
12include_spip('inc/presentation');
13include_spip('inc/acces');
14include_spip('inc/spiplistes_api_globales');
15
16/**
17 * Import d'un fichier texte, liste d'abonnes
18 *
19 * Le fichier doit etre de type CVS.
20 * Les enregistrements sont separes par une tabulation
21 * ou un point-virgule ';'
22 * Exemple:
23 * me@example.com;mylogin;My Name;0minirezo
24 *
25 * @param string $filename
26 * @param string $realname
27 * @param array|int $abos_liste
28 * @param string $format_abo
29 * @param string $separateur
30 * @param bool $flag_admin pas utilise'!
31 * @param bool $listes_autorisees pas utilise'!
32 * @param bool $forcer_abo
33 * @return string
34 * @todo code a nettoyer
35 */
36function spiplistes_import (
37        $filename
38        , $realname
39        , $abos_liste
40        , $format_abo = 'non'
41        , $separateur = "\t"
42        , $flag_admin
43        , $listes_autorisees
44        , $forcer_abo = false
45) {
46               
47        $result_affiche = '';
48
49        if (is_readable($filename)
50           && ($abos_liste = (spiplistes_ids_valides ($abos_liste))))
51        {
52               
53                // recupere les logins et mails existants dans la base
54                // pour eviter les doublons
55               
56                $current_auteurs = array();
57               
58                $compteur = array(
59                        'creer' => 0
60                        , 'abonner' => 0
61                        , 'existe' => 0
62                        , 'format' => 0
63                );
64               
65                /**
66                 * Noter les comptes qui ont un email
67                 */
68                if ($sql_result = sql_select(
69                                                                 array('id_auteur'
70                                                                           , 'login'
71                                                                           , 'email'
72                                                                           , 'nom'
73                                                                           )
74                                                                 , array('spip_auteurs')
75                                                                 , array('email<>'.sql_quote(''))
76                                                                 )
77                ) {
78                        while($row = spip_fetch_array($sql_result))
79                        {
80                                $mail = strtolower($row['email']);
81                                $current_auteurs[$mail] = array('login' => strtolower($row['login'])
82                                                                                   , 'id_auteur' => $row['id_auteur']
83                                                                                   , 'nom' => $row['nom']
84                                                                                   , 'format' => $row['format']
85                                                                                   );
86                        }
87                }
88               
89                if ($forcer_abo)
90                {
91                        /**
92                         * Noter le format de réception par défaut
93                         * pour chaque auteur
94                         */
95                        $a_formats = spiplistes_formats_defaut_lister();
96                        foreach ($current_auteurs as $mail => $value)
97                        {
98                                $id_auteur = $value['id_auteur'];
99                                /**
100                                 * Reprendre le format désiré par l'abonné.
101                                 */
102                                if (isset($a_formats[$id_auteur])) {
103                                        $current_auteurs[$mail]['format'] = $a_formats[$id_auteur];
104                                }
105                        }
106                }
107               
108                // charger la table des abonnements en ram afin d'eviter les petites requettes
109                $abonnements = spiplistes_abonnements_lister ();
110               
111                // import du fichier transmis
112                spiplistes_log('IMPORT FILE: '.$realname);
113
114                $new_entries = file($filename);
115               
116                //syslog(LOG_NOTICE, 'memory_get_usage[3]: ' . memory_get_usage());
117               
118                $nb_new_entries = count($new_entries);
119               
120                $bad_dupli = $bad_email = 0;
121                $statuts_auteurs = array('6forum', '1comite', '0minirezo');
122               
123                /**
124                 * Tableau des nouveaux comptes
125                 * Le compte est créé ici avec son format de réception
126                 */
127                $stack_new_auteurs = array();
128               
129                /**
130                 * Tableau des auteurs (comptes déjà existants)
131                 * qu'il faut abonner aux listes souhaitées
132                 */
133                $stack_new_abonnes = array();
134               
135                //syslog(LOG_NOTICE, 'memory_get_usage[2]: ' . memory_get_usage());
136                //syslog(LOG_NOTICE, 'memory_get_peak_usage[2]: ' . memory_get_peak_usage());
137               
138                $start_time = microtime(1);
139               
140                // statut temporaire
141                $tmp_statut = '6abo'.date('YmdGis');
142               
143                for($jj = 0; $jj < $nb_new_entries; $jj++)
144                {
145                        $nouvelle_entree = trim($new_entries[$jj]);
146                       
147                        if(!empty($nouvelle_entree)
148                           // ni une ligne de commentaire
149                           && (
150                                   ($char = substr($nouvelle_entree, 0, 1))
151                                   && ($char != '#')
152                                   && ($char != '/')
153                                )
154                        ) {
155                                list($email, $login, $nom) = explode($separateur, $nouvelle_entree);
156                               
157                                $email = strtolower(trim($email));
158
159                                $mail_exist = FALSE;
160                               
161                                $email = email_valide($email);
162                               
163                                if ($email
164                                   &&   (
165                                                !($mail_exist = array_key_exists($email, $current_auteurs))
166                                                || $forcer_abo
167                                                )
168                                )
169                                {
170                                        // si le compte n'existe pas, le creer
171                                        if(!$mail_exist)
172                                        {
173                                                // commencer par calculer le login
174                                                $login = trim($login);
175                                                if(empty($login))
176                                                {
177                                                        $login = spiplistes_login_from_email($email);
178                                                }
179                                                else
180                                                {
181                                                        $login = strtolower($login);
182                                                }
183                                               
184                                                // puis le nom
185                                                $nom = trim($nom);
186                                                if(empty($nom))
187                                                {
188                                                        $nom = ucfirst($login);
189                                                }
190                                               
191                                                // ajoute l'invite' dans la table des auteurs
192                                                $pass = creer_pass_aleatoire(8, $email);
193                                       
194                                                // nouvel abo dans la pile des "a creer"
195                                                $stack_new_auteurs[] = array(
196                                                        'nom' => $nom
197                                                        , 'email' => $email
198                                                        , 'login' => $login
199                                                        , 'pass' => md5($pass)
200                                                        , 'statut' => $tmp_statut
201                                                        , 'htpass' => generer_htpass($pass)
202                                                );
203                                        } // end if(!$mail_exist)
204                                       
205                                        // adresse mail existe dans la base
206                                        // si on passe par ici, c'est sous-entendu $forcer_abo
207                                        // (abonne' un compte existant)
208                                        else
209                                        {
210                                                $stack_new_abonnes[] = intval($current_auteurs[$email]['id_auteur']);
211                                        }
212                                }
213                               
214                                /**
215                                 * Signale (en mode debug) si la
216                                 * ligne est erronée.
217                                 */
218                                if (!$email) {
219                                        spiplistes_log ('BAD ENTRY @ LINE #'.$jj.': '.$nouvelle_entree);
220                                }
221                        }
222                } // end for
223                               
224                $creer_comptes = count($stack_new_auteurs);
225                spiplistes_debug_log ('CREATE '.$creer_comptes.' new accounts');
226               
227                /**
228                 * Appliquer le statut temporaire aux comptes
229                 * existants qui n'ont pas de format.
230                 * Le format sera appliqué dans la requete plus bas.
231                 */
232                if ($inscrire_abos)
233                {
234                        $forcer_statuts = array();
235                        foreach ($current_auteurs as $mail => $value)
236                        {
237                                if (!$value['format']) {
238                                        $forcer_statuts[] = $value['id_auteur'];
239                                }
240                        }
241                        if (count($forcer_statuts))
242                        {
243                                if (sql_update(array('spip_auteurs')
244                                           , array('statut' => sql_quote($tmp_statut))
245                                           , array('id_auteur IN ('.implode(',', $forcer_statuts).')')
246                                           ) === FALSE
247                                )
248                                {
249                                        spiplistes_sqlerror_log('stack_format_abo');
250                                }
251                        }
252                }
253               
254                if ($creer_comptes || $inscrire_abos)
255                {
256                        /**
257                         * Tableau des comptes créés
258                         */
259                        $stack_comptes_crees = array();
260                       
261                        if ($creer_comptes)
262                        {
263                                $sql_col_names = '('.implode(',', array_keys($stack_new_auteurs[0])).')';
264                                $sql_col_values = '';
265                               
266                                //syslog(LOG_NOTICE, 'memory_get_usage[5]: ' . memory_get_usage());
267                               
268                                foreach($stack_new_auteurs as $auteur)
269                                {
270                                        $values = array_map('sql_quote', $auteur);
271                                        $sql_col_values .= '('.implode(',', $values).'),';
272                                }
273                                $sql_col_values = rtrim($sql_col_values,',');
274                               
275                                if (sql_insert('spip_auteurs', $sql_col_names, $sql_col_values))
276                                {
277                                        $sql_select = array('id_auteur');
278                                        $sql_from = array('spip_auteurs');
279                                        $sql_where[] = 'statut='.sql_quote($tmp_statut);
280                                       
281                                        if ($sql_result = sql_select (
282                                                $sql_select
283                                                , $sql_from
284                                                , $sql_where
285                                                )) {
286                                                while ($row = sql_fetch($sql_result)) {
287                                                        $stack_new_abonnes[] = $row['id_auteur'];
288                                                }
289                                        }
290                                }
291                        }
292                        $inscrire_abos = count($stack_new_abonnes);
293                        spiplistes_debug_log ('SUBCRIBE '.$inscrire_abos.' accounts');
294                       
295                        //syslog(LOG_NOTICE, 'memory_get_usage[6]: ' . memory_get_usage());
296                       
297                        /**
298                         * Inscrire les abonnements
299                         * des comptes existants
300                         */
301                        if ($inscrire_abos) {
302                                foreach($abos_liste as $id_liste)
303                                {
304                                        /**
305                                         * Pour les membres déjà inscrits,
306                                         * abonner à la liste si pas déjà abonné
307                                         */
308                                        foreach (array_merge(
309                                                                $stack_comptes_crees
310                                                                , $stack_new_abonnes) as $id_auteur)
311                                        {
312                                                if ((!isset($abonnements[$id_liste]))
313                                                        || (!in_array($id_auteur, $abonnements[$id_liste]))
314                                                ) {
315                                                        spiplistes_abonnements_ajouter ($id_auteur, $id_liste);
316                                                }
317                                        } // foreach
318                                } // foreach
319                        } // if
320               
321                        /**
322                         * Appliquer le format de réception
323                         * @todo A remplacer par la fonction en API
324                         */
325                        if(sql_query(
326                                'INSERT INTO spip_auteurs_elargis
327                                                (id_auteur,`spip_listes_format`) SELECT a.id_auteur,'.sql_quote($format_abo)
328                                                                .' FROM spip_auteurs AS a WHERE a.statut='.sql_quote($tmp_statut))
329                           === FALSE
330                        )
331                        {
332                                spiplistes_sqlerror_log('import: nouveaux formats dans spip_auteurs_elargis');
333                        }
334                }
335               
336               
337                // redonner le bon statut visiteur aux nouveaux
338                sql_update(array('spip_auteurs')
339                                   , array('statut' => sql_quote('6forum'))
340                                   , array('statut='.sql_quote($tmp_statut))
341                                   );
342
343                // fin des req
344
345                $result_affiche .=
346                        ($tt = ($ii = count($stack_new_auteurs)) + ($jj = count($stack_new_abonnes)))
347                        ?       '<ul>'.PHP_EOL
348                                . '<li class="verdana2">'._T('spiplistes:nb_comptes_importees_en_ms_dont_'
349                                                                                 , array('nb' => $ii, 'ms' => (microtime(1) - $start_time)))
350                                . '<ul>'.PHP_EOL
351                                        . '<li>'._T('spiplistes:nb_fiches_crees', array('nb' => $ii)).'</li>'.PHP_EOL
352                                        //. '<li>'._T('spiplistes:nb_comptes_modifies', array('nb' => $jj)).'</li>'.PHP_EOL
353                                        . '<li>'._T('spiplistes:nb_comptes_abonnes', array('nb' => $jj)).'</li>'.PHP_EOL
354                                        //. '<li>'._T('spiplistes:nb_comptes_ignores', array('nb' => $jj)).'</li>'.PHP_EOL
355                                . '</ul>'.PHP_EOL
356                                . '</li>'.PHP_EOL
357                                . '</ul>'.PHP_EOL
358                        : '<br />'._T('spiplistes:pas_dimport').PHP_EOL
359                        ;
360
361                if($bad_dupli) {
362                        $result_affiche .= '<br />'._T('pass_erreur').' email: '._T('spiplistes:n_duplicata_mail', array('n' => $bad_dupli)).PHP_EOL;
363                }
364                if($bad_email) {
365                        $result_affiche .= '<br />'._T('pass_erreur').' email: '._T('spiplistes:n_incorrect_mail', array('n' => $bad_email)).PHP_EOL;
366                }
367                $result_affiche = _T('spiplistes:fichier_') . ' : <strong>'.$realname.'</strong><br />'.PHP_EOL
368                        . _T('spiplistes:' . ((count($abos_liste) > 1) ? 'listes_de_destination_s' : 'liste_de_destination_s')
369                                 , array('s' => '#' . implode(',#', $abos_liste))) .'<br />'.PHP_EOL
370                        . $result_affiche
371                        ;
372        }
373        return($result_affiche);
374} // spiplistes_import()
375
376/**
377 * Controler les id donnes
378 *
379 * L'argument est soit un int positif, soit
380 * un tableau d'int positifs.
381 * @param int|array liste à controler
382 * @return array|bool
383 */
384function spiplistes_ids_valides ($ids) {
385       
386        if (!is_array($ids)) {
387                $ids = array ($ids);
388        }
389        if (is_array($ids)) {
390                $array = array();
391                foreach ($ids as $id) {
392                        $ii = intval ($id);
393                        if ($id > 0) {
394                                $array[] = $id;
395                        }
396                }
397                return ($array);
398        }
399        return (FALSE);
400}
Note: See TracBrowser for help on using the repository browser.