Changeset 47640 in spip-zone


Ignore:
Timestamp:
May 10, 2011, 3:33:37 PM (10 years ago)
Author:
paladin@…
Message:

Révision du module d'import. Le 'Forcer les abonnements' ne fonctionnait pas.

Location:
_plugins_/spip-listes/spip-listes_1_9_3
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/spip-listes/spip-listes_1_9_3/exec/spiplistes_import_export.php

    r47408 r47640  
    3030
    3131include_spip('inc/spiplistes_api_globales');
     32include_spip('inc/presentation');
     33include_spip('inc/acces');
     34include_spip('inc/spiplistes_api');
     35include_spip('inc/spiplistes_api_presentation');
    3236
    3337/**
     
    3539*/
    3640function exec_spiplistes_import_export() {
    37 
    38         include_spip('inc/presentation');
    39         include_spip('inc/acces');
    40         include_spip('inc/spiplistes_api');
    41         include_spip('inc/spiplistes_api_presentation');
    4241
    4342        global $connect_statut
  • _plugins_/spip-listes/spip-listes_1_9_3/inc/spiplistes_api.php

    r47621 r47640  
    446446
    447447/**
     448 * Inventaire des abonnements.
     449 * Tableau dont l'index est l'ID de la liste
     450 * et la valeur un tableau des ID abonnés
     451 * @param string|array $sql_where
     452 * @version CP-20110510
     453 * @return array|bool
     454 */
     455function spiplistes_abonnements_lister ($sql_where = '') {
     456       
     457        if(($sql_result = sql_select('id_auteur,id_liste'
     458                                                                , 'spip_auteurs_listes'
     459                                                                , $sql_where
     460                                                                )
     461                ) !== FALSE)
     462        {
     463                $listes = array();
     464               
     465                while($row = sql_fetch($sql_result))
     466                {
     467                        $ii = $row['id_liste'];
     468                       
     469                        if(!isset($listes[$ii]))
     470                        {
     471                                $listes[$ii] = array();
     472                        }
     473                        $listes[$ii][] = $row['id_auteur'];
     474                }
     475                return ($listes);
     476        }
     477        else {
     478                spiplistes_sqlerror_log('spiplistes_abonnements_lister ()');
     479        }
     480        return (FALSE);
     481}
     482
     483/**
    448484 ******************************************************************************
    449485        Les fonctions spiplistes_listes_*() concernent les listes
     
    851887        }
    852888        return ($defaut);
     889}
     890
     891/**
     892 * Inventaire des formats de réception par défaut.
     893 *
     894 * Tableau dont l'index est l'ID de l'auteur
     895 * et la valeur le format de réception par défaut.
     896 *
     897 * @param string|array $sql_where
     898 * @version CP-20110510
     899 * @return array|bool
     900 */
     901function spiplistes_formats_defaut_lister ($sql_where = '') {
     902       
     903        if(
     904                ($sql_result = sql_select('id_auteur,`spip_listes_format` AS format'
     905                                                                        , 'spip_auteurs_elargis'
     906                                                        , $sql_where
     907                                                                        )
     908        ) !== FALSE )
     909        {
     910                $auteurs = array();
     911       
     912                while($row = sql_fetch($sql_result)) {
     913                        $auteurs[$row['id_auteur']] = $row['format'];
     914                }
     915                return ($auteurs);
     916        }
     917        else {
     918                spiplistes_sqlerror_log('spiplistes_formats_defaut_lister ()');
     919        }
     920        return (FALSE);
    853921}
    854922
  • _plugins_/spip-listes/spip-listes_1_9_3/inc/spiplistes_import.php

    r47471 r47640  
    3434 * @todo code a nettoyer
    3535 */
    36 function spiplistes_import(
     36function spiplistes_import (
    3737        $filename
    3838        , $realname
     
    4444        , $forcer_abo = false
    4545) {
     46               
    4647        $result_affiche = '';
    4748
    48         if(is_readable($filename))
     49        if (is_readable($filename)
     50           && ($abos_liste = (spiplistes_ids_valides ($abos_liste))))
    4951        {
    50                 // abonner les adresses importees
    51                 // aux listes...
    52                 if(!is_array($abos_liste))
    53                 {
    54                         if(($ii = intval($abos_liste)) <= 0)
    55                         {
    56                                 return(false);
    57                         }
    58                         $abos_liste = array($ii);
    59                 }
    60                 else
    61                 {
    62                         $abos_liste = array_map('intval', $abos_liste);
    63                 }
    6452               
    6553                // recupere les logins et mails existants dans la base
    6654                // pour eviter les doublons
    6755               
    68                 $current_entries = array();
    69                 $sql_result = sql_select(array('id_auteur', 'login', 'email', 'nom'), 'spip_auteurs');
    70                
    71                 while($row = spip_fetch_array($sql_result))
    72                 {
    73                         // ne prendre que les comptes qui ont un email
    74                         if($m = $row['email']) {
    75                                 $m = strtolower($m);
    76                                 $current_entries[$m] = array('login' => strtolower($row['login'])
     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'])
    7782                                                                                   , 'id_auteur' => $row['id_auteur']
    7883                                                                                   , 'nom' => $row['nom']
     84                                                                                   , 'format' => $row['format']
    7985                                                                                   );
    8086                        }
    8187                }
    82                 //syslog(LOG_NOTICE, 'memory_get_usage[2]: ' . memory_get_usage());
    83                
    84                 //
    85                 spiplistes_log('import fichier '.$filename);
     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: filename '.$realname);
     113
    86114                $new_entries = file($filename);
    87115               
     
    93121                $statuts_auteurs = array('6forum', '1comite', '0minirezo');
    94122               
    95                 // charger la table des abonnements en ram afin d'eviter les petites requettes
    96                 $abonnements = array();
    97                 if(($sql_result = sql_select('id_auteur,id_liste'
    98                                                                         , 'spip_auteurs_listes')
    99                         ) !== false)
    100                 {
    101                         while($row = sql_fetch($sql_result)) {
    102                                 if(!isset($abonnements[$row['id_liste']])) {
    103                                         $abonnements[$row['id_liste']] = array();
    104                                 }
    105                                 $abonnements[$row['id_liste']][] = $row['id_auteur'];
    106                         }
    107                 }
    108                 else {
    109                         spiplistes_sqlerror_log('module import (abonnements)');
    110                 }
    111                
    112                 if($forcer_abo)
    113                 {
    114                         $auteurs_format = array();
    115                         // charger la table des formats afin d'eviter les petites requettes
    116                         if(($sql_result = sql_select("id_auteur,`spip_listes_format` AS format"
    117                                                                                 , 'spip_auteurs_elargis')) !== false)
    118                         {
    119                                 while($row = sql_fetch($sql_result)) {
    120                                         $auteurs_format[$row['id_auteur']] = $row['format'];
    121                                 }
    122                         }
    123                         else
    124                         {
    125                                 spiplistes_sqlerror_log("module import (format)");
    126                         }
    127                 }
    128                
    129                 // les formats
    130                 $modifier_format = array();
    131                
    132                 $err_import = _T('spiplistes:erreur_import_base');
     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();
    133134               
    134135                //syslog(LOG_NOTICE, 'memory_get_usage[2]: ' . memory_get_usage());
     
    136137               
    137138                $start_time = microtime(1);
    138                
    139                 $stack_new_auteurs = array();
    140139               
    141140                // statut temporaire
     
    158157                                $email = strtolower(trim($email));
    159158
    160                                 $mail_exist = false;
    161                                
    162                                 if(($email = email_valide($email))
     159                                $mail_exist = FALSE;
     160                               
     161                                $email = email_valide($email);
     162                               
     163                                if ($email
    163164                                   &&   (
    164                                                 !($mail_exist = array_key_exists($email, $current_entries))
     165                                                !($mail_exist = array_key_exists($email, $current_auteurs))
    165166                                                || $forcer_abo
    166167                                                )
    167168                                )
    168169                                {
     170                                        // si le compte n'existe pas, le creer
    169171                                        if(!$mail_exist)
    170172                                        {
    171                                                 // si le compte n'existe pas, le creer
    172                                                
    173173                                                // commencer par calculer le login
    174174                                                $login = trim($login);
     
    181181                                                        $login = strtolower($login);
    182182                                                }
     183                                               
    183184                                                // puis le nom
    184185                                                $nom = trim($nom);
     
    206207                                        else
    207208                                        {
    208                                                 $id_auteur = intval($current_entries[$email]['id_auteur']);
    209                                                
    210                                                 // forcer le format dans la foulee
    211                                                 if(!isset($auteurs_format[$id_auteur]))
    212                                                 {
    213                                                         $modifier_format[] = '(' . sql_quote($id_auteur) . ',' . sql_quote($format_abo) . ')';
    214                                                 }
     209                                                $stack_new_abonnes[] = intval($current_auteurs[$email]['id_auteur']);
    215210                                        }
    216                                         // est-ce vraiment utile (voir plus bas)
    217                                 }
    218                                 else
     211                                }
     212                        }
     213                } // end for
     214                               
     215                $creer_comptes = count($stack_new_auteurs);
     216                $inscrire_abos = count($stack_new_abonnes);
     217
     218                /**
     219                 * Appliquer le statut temporaire aux comptes
     220                 * existants qui n'ont pas de format.
     221                 * Le format sera appliqué dans la requete plus bas.
     222                 */
     223                if($inscrire_abos)
     224                {
     225                        $forcer_statuts = array();
     226                        foreach ($current_auteurs as $mail => $value)
     227                        {
     228                                if (!$value['format']) {
     229                                        $forcer_statuts[] = $value['id_auteur'];
     230                                }
     231                        }
     232                        if (count($forcer_statuts))
     233                        {
     234                                if (sql_update(array('spip_auteurs')
     235                                           , array('statut' => sql_quote($tmp_statut))
     236                                           , array('id_auteur IN ('.implode(',', $forcer_statuts).')')
     237                                           ) === FALSE
     238                                )
    219239                                {
    220                                         if($mail_exist) {
    221                                                 $bad_dupli++;
    222                                                 spiplistes_log('import dupli: '.$mail);
    223                                         }
    224                                         else {
    225                                                 $bad_email++;
    226                                                 spiplistes_log('import bad: '.$mail);
    227                                         }
    228                                 }
    229                         }
    230                 } // end for($jj = 0; $jj < $nb_new_entries; $jj++)
    231                                
    232                 // importer les nouveaux abonnés
    233                 if(count($stack_new_auteurs))
     240                                        spiplistes_sqlerror_log('stack_format_abo');
     241                                }
     242                        }
     243                }
     244               
     245                if ($creer_comptes || $inscrire_abos)
    234246                {
    235                         $sql_col_names = '('.implode(',', array_keys($stack_new_auteurs[0])).')';
    236                         $sql_col_values = '';
     247                        /**
     248                         * Tableau des comptes créés
     249                         */
     250                        $stack_comptes_crees = array();
    237251                       
    238                         //syslog(LOG_NOTICE, 'memory_get_usage[5]: ' . memory_get_usage());
    239                        
    240                         foreach($stack_new_auteurs as $auteur)
    241                         {
    242                                 $values = array_map('sql_quote', $auteur);
    243                                 $sql_col_values .= '('.implode(',', $values).'),';
    244                         }
    245                         $sql_col_values = rtrim($sql_col_values,',');
    246                        
    247                         $r = sql_insert('spip_auteurs', $sql_col_names, $sql_col_values);
    248                        
    249                         spiplistes_debug_log ('size of imported values: ' . strlen($sql_col_values));
     252                        if ($creer_comptes)
     253                        {
     254                                $sql_col_names = '('.implode(',', array_keys($stack_new_auteurs[0])).')';
     255                                $sql_col_values = '';
     256                               
     257                                //syslog(LOG_NOTICE, 'memory_get_usage[5]: ' . memory_get_usage());
     258                               
     259                                foreach($stack_new_auteurs as $auteur)
     260                                {
     261                                        $values = array_map('sql_quote', $auteur);
     262                                        $sql_col_values .= '('.implode(',', $values).'),';
     263                                }
     264                                $sql_col_values = rtrim($sql_col_values,',');
     265                               
     266                                $r = sql_insert('spip_auteurs', $sql_col_names, $sql_col_values);
     267                                $stack_comptes_crees[] = $r;
     268                        }
    250269                       
    251270                        //syslog(LOG_NOTICE, 'memory_get_usage[6]: ' . memory_get_usage());
    252271                       
    253                         // nouveaux abonnements
    254                         foreach($abos_liste as $id_liste)
    255                         {
    256                                 // un INSERT sans VALUES
    257                                 // @todo: vérifier compatibilite sqlite et pg
    258                                 if(sql_query(
    259                                         'INSERT INTO spip_auteurs_listes
    260                                                                 (id_auteur,id_liste) SELECT a.id_auteur,'.$id_liste
    261                                                                         .' FROM spip_auteurs AS a WHERE a.statut='.sql_quote($tmp_statut))
    262                                    === false
    263                                 )
     272                        /**
     273                         * Inscrire les abonnements
     274                         * des comptes existants
     275                         */
     276                        if ($inscrire_abos) {
     277                                foreach($abos_liste as $id_liste)
    264278                                {
    265                                         spiplistes_sqlerror_log('import nouveaux abos dans spip_auteurs_listes');
    266                                 }
    267                         }
    268                        
    269                         // format pour les nouveaux auteurs
    270                                 // un INSERT sans VALUES
    271                                 // @todo: vérifier compatibilite sqlite et pg
     279                                        /**
     280                                         * Pour les membres déjà inscrits,
     281                                         * abonner à la liste si pas déjà abonné
     282                                         */
     283                                        foreach (array_merge(
     284                                                                $stack_comptes_crees
     285                                                                , $stack_new_abonnes) as $id_auteur)
     286                                        {
     287                                                if ((!isset($abonnements[$id_liste]))
     288                                                        || (!in_array($id_auteur, $abonnements[$id_liste]))
     289                                                ) {
     290                                                        spiplistes_abonnements_ajouter ($id_auteur, $id_liste);
     291                                                }
     292                                        } // foreach
     293                                } // foreach
     294                        } // if
     295               
     296                        /**
     297                         * Appliquer le format de réception
     298                         * @todo A remplacer par la fonction en API
     299                         */
    272300                        if(sql_query(
    273301                                'INSERT INTO spip_auteurs_elargis
    274302                                                (id_auteur,`spip_listes_format`) SELECT a.id_auteur,'.sql_quote($format_abo)
    275303                                                                .' FROM spip_auteurs AS a WHERE a.statut='.sql_quote($tmp_statut))
    276                            === false
     304                           === FALSE
    277305                        )
    278306                        {
    279                                 spiplistes_sqlerror_log('import nouveauxformats dans spip_auteurs_elargis');
    280                         }
    281                
    282                 }
    283                
    284                 // Comptes deja existants, inclus dans le fichier import
    285                 // - changer son format de réception ?
    286                 // - l'ajouter aux listes sélectionnées ?
    287                 // - ou ignorer ?
    288                 if(count($modifier_format))
    289                 {
    290                         // pour l'instant: ignorer !
    291                         //
    292                 }
     307                                spiplistes_sqlerror_log('import: nouveauxformats dans spip_auteurs_elargis');
     308                        }
     309                }
     310               
    293311               
    294312                // redonner le bon statut visiteur aux nouveaux
    295                 sql_update(array('spip_auteurs'), array('statut' => sql_quote('6forum')), array('statut='.sql_quote($tmp_statut)));
     313                sql_update(array('spip_auteurs')
     314                                   , array('statut' => sql_quote('6forum'))
     315                                   , array('statut='.sql_quote($tmp_statut))
     316                                   );
    296317
    297318                // fin des req
    298319
    299320                $result_affiche .=
    300                         ($tt = ($ii = count($stack_new_auteurs)) + ($jj = count($modifier_format)))
     321                        ($tt = ($ii = count($stack_new_auteurs)) + ($jj = count($stack_new_abonnes)))
    301322                        ?       '<ul>'.PHP_EOL
    302323                                . '<li class="verdana2">'._T('spiplistes:nb_comptes_importees_en_ms_dont_'
     
    305326                                        . '<li>'._T('spiplistes:nb_fiches_crees', array('nb' => $ii)).'</li>'.PHP_EOL
    306327                                        //. '<li>'._T('spiplistes:nb_comptes_modifies', array('nb' => $jj)).'</li>'.PHP_EOL
    307                                         . '<li>'._T('spiplistes:nb_comptes_ignores', array('nb' => $jj)).'</li>'.PHP_EOL
     328                                        . '<li>'._T('spiplistes:nb_comptes_abonnes', array('nb' => $jj)).'</li>'.PHP_EOL
     329                                        //. '<li>'._T('spiplistes:nb_comptes_ignores', array('nb' => $jj)).'</li>'.PHP_EOL
    308330                                . '</ul>'.PHP_EOL
    309331                                . '</li>'.PHP_EOL
     
    312334                        ;
    313335
    314                
    315336                if($bad_dupli) {
    316337                        $result_affiche .= '<br />'._T('pass_erreur').' email: '._T('spiplistes:n_duplicata_mail', array('n' => $bad_dupli)).PHP_EOL;
     
    327348        return($result_affiche);
    328349} // spiplistes_import()
     350
     351/**
     352 * Controler les id donnes
     353 *
     354 * L'argument est soit un int positif, soit
     355 * un tableau d'int positifs.
     356 * @param int|array liste à controler
     357 * @return array|bool
     358 */
     359function spiplistes_ids_valides ($ids) {
     360       
     361        if (!is_array($ids)) {
     362                $ids = array ($ids);
     363        }
     364        if (is_array($ids)) {
     365                $array = array();
     366                foreach ($ids as $id) {
     367                        $ii = intval ($id);
     368                        if ($id > 0) {
     369                                $array[] = $id;
     370                        }
     371                }
     372                return ($array);
     373        }
     374        return (FALSE);
     375}
  • _plugins_/spip-listes/spip-listes_1_9_3/lang/spiplistes_fr.php

    r47557 r47640  
    317317, 'nb_fiches_crees' => '@nb@ comptes cr&#233;&#233;s'
    318318, 'nb_comptes_modifies' => '@nb@ comptes modifi&#233;s'
     319, 'nb_comptes_abonnes' => '@nb@ comptes d&#233;j&#224; dans la base'
    319320, 'nb_comptes_ignores' => '@nb@ comptes ignor&#233;s (d&#233;j&#224; dans la base)'
    320321, 'format_de_reception_' => 'Format de r&#233;ception : '
Note: See TracChangeset for help on using the changeset viewer.