Changeset 95545 in spip-zone


Ignore:
Timestamp:
Feb 27, 2016, 5:18:38 PM (3 years ago)
Author:
guillaume.wauquier@…
Message:

Correction d'un bug dans la détection des fichiers téléchargés et ajout si inexistant du slash à la fin du chemin 'Dossier des données'

Location:
_plugins_/COG/trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/COG/trunk/formulaires/importer_cog.php

    r94873 r95545  
    22
    33
    4 function formulaires_importer_cog_charger(){
    5 include_spip('cog_config');
    6 include_spip('inc/cog_import');
    7 include_spip('inc/config');
    8 $tab_objet=cog_config_tab_fichier();
    9 $emplacement=_DIR_TMP.lire_config('cog/chemin_donnee');
    10 foreach($tab_objet as &$objet)
    11         {
    12                 $fichier_manquant=false;
    13 
    14                 $tab_fichier=cog_tab_fichier_telecharger($objet['fichier']);
    15 
    16                 foreach($tab_fichier as $fichier)
    17                 {
    18                         $infos_fichier = pathinfo($fichier);
    19                         if(preg_match('`^http`i',$fichier)) {
    20 
    21 
    22                                 $nom_fichier = $emplacement . $infos_fichier['filename'] . '.' . $infos_fichier['extension'];
    23                                 if ($infos_fichier['extension'] == 'zip')
    24                                         $nom_fichier = $emplacement . $infos_fichier['filename'] . '.txt';
    25                                 if (!file_exists($nom_fichier))
    26                                         $fichier_manquant = true;
    27                                 $nom_fichier = $emplacement . $infos_fichier['filename'] . '.xls';
    28                                 if ($fichier_manquant && !file_exists($nom_fichier))
    29                                         $fichier_manquant = true;
    30                         }
    31                         else{
    32                                 $nom_fichier=realpath(_DIR_PLUGIN_COG.'/data').'/'.$infos_fichier['filename'] . '.txt';
    33                                 if (!file_exists($nom_fichier))
    34                                         $fichier_manquant = true;
    35                         }
    36                 }
    37                 $objet['fichier_manquant']=$fichier_manquant;
    38         }
    39 return array('objet'=>'','tab_objet'=>$tab_objet);
    40 }
    41 
    42 
    43 function formulaires_importer_cog_verifier_dist(){
    44         include_spip('cog_config');
    45         include_spip('inc/config');
    46         $tab_objet=cog_config_tab_fichier();
    47         $emplacement=_DIR_TMP.lire_config('cog/chemin_donnee');
    48         $erreurs=array();
    49         if ($objet = _request('objet')) {
    50                 if (!isset($tab_objet[$objet])) {
    51                         $erreurs['fichier'] = _T('cog:fichier_incorrect');
    52                         $erreurs['message_erreur'] .= _T('cog:fichier_incorrect');
    53                 }else {
    54                         $tab_objet=$tab_objet[$objet]['fichier'];
    55                         if(is_array($tab_objet))
    56                                 {
    57                                 $tab_objet=$tab_objet;
    58                                 }
    59                         else
    60                                 {
    61                                 $tab_objet=array($tab_objet);
    62                                 }
    63                         foreach($tab_objet as $fichier)
    64                         {
    65                         $infos_fichier=pathinfo($fichier);
    66                         $extension = $infos_fichier['extension'];
    67                         if($extension =='zip')
    68                                 $extension = 'txt';
    69 
    70                         $fichier=$infos_fichier['filename'].'.'.$extension;
    71                         $emplacement_local=realpath(_DIR_PLUGIN_COG.'/data').'/';
    72                         if(!file_exists($emplacement.$fichier) && !file_exists($emplacement_local.$fichier))
    73                                 $fichier=$infos_fichier['filename'].'.xls';
    74                         if (!file_exists($emplacement.$fichier) && !file_exists($emplacement_local.$fichier)) {
    75                                 $erreurs['fichier'] .= _T('cog:fichier_introuvable')." ".$emplacement.$infos_fichier['filename'].'.[txt|xls]';
    76                                 $erreurs['message_erreur'] .= _T('cog:fichier_introuvable');
    77                         }
    78                         }
    79                 }
    80         }
    81 
    82         return $erreurs;
     4function formulaires_importer_cog_charger()
     5{
     6    include_spip('cog_config');
     7    include_spip('inc/cog_import');
     8    include_spip('inc/config');
     9    $tab_objet = cog_config_tab_fichier();
     10    $emplacement = _DIR_TMP . lire_config('cog/chemin_donnee');
     11    $emplacement .= (substr($emplacement, -1) == "/") ? '' : "/";
     12    foreach ($tab_objet as &$objet) {
     13        $fichier_manquant = false;
     14
     15        $tab_fichier = cog_tab_fichier_telecharger($objet['fichier']);
     16
     17        foreach ($tab_fichier as $fichier) {
     18            $infos_fichier = pathinfo($fichier);
     19            if (preg_match('`^http`i', $fichier)) {
     20
     21                $nom_fichier = $emplacement . $infos_fichier['filename'] . '.' . $infos_fichier['extension'];
     22                if ($infos_fichier['extension'] == 'zip') {
     23                    $nom_fichier = $emplacement . $infos_fichier['filename'] . '.txt';
     24                }
     25                if (!file_exists($nom_fichier)) {
     26                    $nom_fichier = $emplacement . $infos_fichier['filename'] . '.xls';
     27                    if (!file_exists($nom_fichier)) {
     28                        $fichier_manquant = true;
     29                    }
     30                }
     31            } else {
     32                $nom_fichier = realpath(_DIR_PLUGIN_COG . '/data') . '/' . $infos_fichier['filename'] . '.txt';
     33                if (!file_exists($nom_fichier)) {
     34                    $fichier_manquant = true;
     35                }
     36            }
     37        }
     38        $objet['fichier_manquant'] = $fichier_manquant;
     39    }
     40    return array('objet' => '', 'tab_objet' => $tab_objet);
     41}
     42
     43
     44function formulaires_importer_cog_verifier_dist()
     45{
     46    include_spip('cog_config');
     47    include_spip('inc/config');
     48    $tab_objet = cog_config_tab_fichier();
     49    $emplacement = _DIR_TMP . lire_config('cog/chemin_donnee');
     50    $emplacement .= (substr($emplacement, -1) == "/") ? '' : "/";
     51    $erreurs = array();
     52    if ($objet = _request('objet')) {
     53        if (!isset($tab_objet[$objet])) {
     54            $erreurs['fichier'] = _T('cog:fichier_incorrect');
     55            $erreurs['message_erreur'] .= _T('cog:fichier_incorrect');
     56        } else {
     57            $tab_objet = $tab_objet[$objet]['fichier'];
     58            if (is_array($tab_objet)) {
     59                $tab_objet = $tab_objet;
     60            } else {
     61                $tab_objet = array($tab_objet);
     62            }
     63            foreach ($tab_objet as $fichier) {
     64                $infos_fichier = pathinfo($fichier);
     65                $extension = $infos_fichier['extension'];
     66                if ($extension == 'zip') {
     67                    $extension = 'txt';
     68                }
     69
     70                $fichier = $infos_fichier['filename'] . '.' . $extension;
     71                $emplacement_local = realpath(_DIR_PLUGIN_COG . '/data') . '/';
     72                if (!file_exists($emplacement . $fichier) && !file_exists($emplacement_local . $fichier)) {
     73                    $fichier = $infos_fichier['filename'] . '.xls';
     74                }
     75                if (!file_exists($emplacement . $fichier) && !file_exists($emplacement_local . $fichier)) {
     76                    $erreurs['fichier'] .= _T('cog:fichier_introuvable') . " " . $emplacement . $infos_fichier['filename'] . '.[txt|xls]';
     77                    $erreurs['message_erreur'] .= _T('cog:fichier_introuvable');
     78                }
     79            }
     80        }
     81    }
     82
     83    return $erreurs;
    8384}
    8485
    8586// http://doc.spip.org/@inc_editer_mot_dist
    86 function formulaires_importer_cog_traiter_dist(){
    87 
    88         include_spip('cog_administrations');
    89          $options=array(
    90          'truncate'=>_request("option_truncate"),
    91          'replace'=>_request("option_ecraser"),
    92          'filtre'=>_request("option_filtre")
    93          );
    94         $objet=_request("objet");
    95          if (function_exists($fonction='cog_import_'._request("fichier")))
    96                 list($message,$erreurs)=$fonction($objet, $options);
    97         else
    98                 list($message,$erreurs)=cog_import($objet, $options);
    99         cog_nouvelle_definition_regionale();
    100 $retour['editable']=true;
    101 if(count($erreurs)==0){
    102         $retour['message_ok'] = $message;
    103 } else {
    104         $retour['message_erreur'] = implode('<br />',$erreurs);
    105 }
    106 
    107 return $retour;
    108 }
    109 
    110 
    111 
    112 
    113 function cog_import_cog_epci($objet,$options)
    114 {
    115 
    116         $options['decalage']=0;
    117         return cog_import($objet,$options);
    118 
    119 }
    120 
    121 
    122 
    123 
    124 
    125 
    126 
    127 
    128 
    129 function cog_applique_filtre($tab_value,$tab_filtres){
    130         foreach($tab_filtres as $col=>$filtre)
    131         {
    132                 if(isset($tab_value[$col]))
    133                 {
    134                 if($tab_value[$col]!=$filtre)
    135                         {
    136                         return false;
    137                         }
    138                 }
    139         }
    140 return true;
    141 }
    142 
    143 
    144 function cog_renvoyer_valeur($ligne,$correspondance)
    145 {
    146         if(isset($correspondance['col']))
    147         {
    148                 return  $ligne[$correspondance['col']];
    149         }
    150         else
    151         {
    152                 return  $ligne[$correspondance];
    153         }
    154 }
    155 
    156 
    157 function cog_ramener_valeur(&$ligne,&$correspondance,$objet,&$contenu_fichier,$one=true)
    158 {
    159         include_spip('inc/config');
    160         include_spip('cog_config');
    161         $tab_result=array();
    162         $objet_config=cog_config_tab_fichier($objet);
    163         $cle_fichier=$correspondance['fichier'];
    164         $col_key1=$correspondance['lien_col_'.objet_type($objet)];
    165         $col_key2=$correspondance['lien_col_'.$cle_fichier];
    166         //Charger le fichier en mémoire
    167         if(!isset($contenu_fichier[$cle_fichier]))
    168                 {
    169                         $emplacement=_DIR_TMP.lire_config('cog/chemin_donnee');
    170                         if(isset($objet_config['xls']))
    171                                 $nom_fichier=$emplacement.$objet_config['xls'][$cle_fichier]['fichier_csv'];
    172                         else
    173                                 $nom_fichier=$emplacement.$objet_config['fichier'][$cle_fichier]['fichier'];
    174                         $pointeur_fichier = fopen($nom_fichier,"r");
    175                         if($pointeur_fichier<>0)
    176                         {
    177                                 $ligne_temp= fgets($pointeur_fichier, 4096);
    178                                 $indice=0;
    179                                 $anc_code='';
    180                                 while (!feof($pointeur_fichier))
    181                                 {
    182                                         $ligne_temp= fgets($pointeur_fichier, 4096);
    183                                         $ligne_temp=explode("\t",$ligne_temp);
    184                                         if(isset($ligne_temp[$col_key2]) and !empty($ligne_temp[$col_key2]) )
    185                                                 $contenu_fichier[$cle_fichier][$col_key2][trim($ligne_temp[$col_key2])][]=$ligne_temp;
    186                                         $indice++;
    187                                 }
    188                         }
    189                 }
    190         if(isset($contenu_fichier[$cle_fichier][$col_key2][$ligne[$col_key1]][0]))
    191                 {
    192                         if($one)
    193                                 {
    194                                 return $contenu_fichier[$cle_fichier][$col_key2][$ligne[$col_key1]][0][$correspondance['num_col']];
    195                                 }
    196                         else
    197                                 {
    198                                         $tab_result=array();
    199                                         foreach($contenu_fichier[$cle_fichier][$col_key2][$ligne[$col_key1]] as $ligne_temp)
    200                                                 {
    201                                                         //echo("<br />".$ligne_temp[$correspondance['col']]);
    202                                                         $tab_result[]=$ligne_temp[$correspondance['num_col']];
    203                                                 }
    204                                         return $tab_result;
    205                                 }
    206                 }
    207         return '';
    208 }
    209 
    210 
    211 
    212 
    213 
    214 
    215 
    216 function cog_import($objet,$options){
    217 include_spip('cog_config');
    218 include_spip('inc/config');
    219 $erreurs=array();
    220         $contenu_fichier=array();
    221         $message="";
    222         $tab_filtres= array();
    223         $option_truncate        = false;
    224         if(isset($options['truncate']))
    225                 $option_truncate= $options['truncate'];
    226         $option_replace = false;
    227         if(isset($options['replace']))
    228                 $option_replace = $options['replace'];
    229         $option_filtre  = '';
    230         if (isset($options['filtre']))
    231                 $option_filtre  = $options['filtre'];
    232         $option_decalage = 1;
    233         if (isset($options['decalage']))
    234                 $option_decalage        = $options['decalage'];
    235 
    236 
    237         $filtres=explode(';',$option_filtre);
    238 
    239 foreach($filtres as $filtre){
    240                 $tab_temp=explode('=',$filtre);
    241                 $tab_filtres[$tab_temp[0]]=$tab_temp[1];
    242                 }
    243         $tab_objet=cog_config_tab_fichier();
    244         $emplacement=_DIR_TMP.lire_config('cog/chemin_donnee');
    245         $message=  'Importation du fichier '.$objet."<br />";
     87function formulaires_importer_cog_traiter_dist()
     88{
     89
     90    include_spip('cog_administrations');
     91    $options = array(
     92        'truncate' => _request("option_truncate"),
     93        'replace' => _request("option_ecraser"),
     94        'filtre' => _request("option_filtre")
     95    );
     96    $objet = _request("objet");
     97    if (function_exists($fonction = 'cog_import_' . _request("fichier"))) {
     98        list($message, $erreurs) = $fonction($objet, $options);
     99    } else {
     100        list($message, $erreurs) = cog_import($objet, $options);
     101    }
     102    cog_nouvelle_definition_regionale();
     103    $retour['editable'] = true;
     104    if (count($erreurs) == 0) {
     105        $retour['message_ok'] = $message;
     106    } else {
     107        $retour['message_erreur'] = implode('<br />', $erreurs);
     108    }
     109
     110    return $retour;
     111}
     112
     113
     114function cog_import_cog_epci($objet, $options)
     115{
     116
     117    $options['decalage'] = 0;
     118    return cog_import($objet, $options);
     119
     120}
     121
     122
     123function cog_applique_filtre($tab_value, $tab_filtres)
     124{
     125    foreach ($tab_filtres as $col => $filtre) {
     126        if (isset($tab_value[$col])) {
     127            if ($tab_value[$col] != $filtre) {
     128                return false;
     129            }
     130        }
     131    }
     132    return true;
     133}
     134
     135
     136function cog_renvoyer_valeur($ligne, $correspondance)
     137{
     138    if (isset($correspondance['col'])) {
     139        return $ligne[$correspondance['col']];
     140    } else {
     141        return $ligne[$correspondance];
     142    }
     143}
     144
     145
     146function cog_ramener_valeur(&$ligne, &$correspondance, $objet, &$contenu_fichier, $one = true)
     147{
     148    include_spip('inc/config');
     149    include_spip('cog_config');
     150    $tab_result = array();
     151    $objet_config = cog_config_tab_fichier($objet);
     152    $cle_fichier = $correspondance['fichier'];
     153    $col_key1 = $correspondance['lien_col_' . objet_type($objet)];
     154    $col_key2 = $correspondance['lien_col_' . $cle_fichier];
     155    //Charger le fichier en mémoire
     156    if (!isset($contenu_fichier[$cle_fichier])) {
     157        $emplacement = _DIR_TMP . lire_config('cog/chemin_donnee');
     158        $emplacement .= (substr($emplacement, -1) == "/") ? '' : "/";
     159        if (isset($objet_config['xls'])) {
     160            $nom_fichier = $emplacement . $objet_config['xls'][$cle_fichier]['fichier_csv'];
     161        } else {
     162            $nom_fichier = $emplacement . $objet_config['fichier'][$cle_fichier]['fichier'];
     163        }
     164        $pointeur_fichier = fopen($nom_fichier, "r");
     165        if ($pointeur_fichier <> 0) {
     166            $ligne_temp = fgets($pointeur_fichier, 4096);
     167            $indice = 0;
     168            $anc_code = '';
     169            while (!feof($pointeur_fichier)) {
     170                $ligne_temp = fgets($pointeur_fichier, 4096);
     171                $ligne_temp = explode("\t", $ligne_temp);
     172                if (isset($ligne_temp[$col_key2]) and !empty($ligne_temp[$col_key2])) {
     173                    $contenu_fichier[$cle_fichier][$col_key2][trim($ligne_temp[$col_key2])][] = $ligne_temp;
     174                }
     175                $indice++;
     176            }
     177        }
     178    }
     179    if (isset($contenu_fichier[$cle_fichier][$col_key2][$ligne[$col_key1]][0])) {
     180        if ($one) {
     181            return $contenu_fichier[$cle_fichier][$col_key2][$ligne[$col_key1]][0][$correspondance['num_col']];
     182        } else {
     183            $tab_result = array();
     184            foreach ($contenu_fichier[$cle_fichier][$col_key2][$ligne[$col_key1]] as $ligne_temp) {
     185                //echo("<br />".$ligne_temp[$correspondance['col']]);
     186                $tab_result[] = $ligne_temp[$correspondance['num_col']];
     187            }
     188            return $tab_result;
     189        }
     190    }
     191    return '';
     192}
     193
     194
     195function cog_import($objet, $options)
     196{
     197    include_spip('cog_config');
     198    include_spip('inc/config');
     199    $erreurs = array();
     200    $contenu_fichier = array();
     201    $message = "";
     202    $tab_filtres = array();
     203    $option_truncate = false;
     204    if (isset($options['truncate'])) {
     205        $option_truncate = $options['truncate'];
     206    }
     207    $option_replace = false;
     208    if (isset($options['replace'])) {
     209        $option_replace = $options['replace'];
     210    }
     211    $option_filtre = '';
     212    if (isset($options['filtre'])) {
     213        $option_filtre = $options['filtre'];
     214    }
     215    $option_decalage = 1;
     216    if (isset($options['decalage'])) {
     217        $option_decalage = $options['decalage'];
     218    }
     219
     220
     221    $filtres = explode(';', $option_filtre);
     222
     223    foreach ($filtres as $filtre) {
     224        $tab_temp = explode('=', $filtre);
     225        $tab_filtres[$tab_temp[0]] = $tab_temp[1];
     226    }
     227    $tab_objet = cog_config_tab_fichier();
     228    $emplacement = _DIR_TMP . lire_config('cog/chemin_donnee');
     229    $emplacement .= (substr($emplacement, -1) == "/") ? '' : "/";
     230    $message = 'Importation du fichier ' . $objet . "<br />";
    246231//      $message.= 'Emplacement du fichier : '.$emplacement."<br />";
    247232
    248 if(is_array($tab_objet[$objet]['fichier']))     {
    249                 $fichier_modele=$tab_objet[$objet]['fichier'][0];}
    250 else{
    251                 $fichier_modele=$tab_objet[$objet]['fichier'];}
    252 
    253         $infos_fichier=pathinfo($fichier_modele);
    254         $extension = $infos_fichier['extension'];
    255         if($extension =='zip')
    256                 $extension = 'txt';
    257 
    258 if(!file_exists($fichier_modele=realpath(_DIR_PLUGIN_COG.'/data').'/'.$infos_fichier['filename'].'.'.$extension)        ){
    259 
    260         if(!file_exists($fichier_modele=$emplacement.$infos_fichier['filename'].'.'.$extension)) {
    261                 if(file_exists($emplacement.$infos_fichier['filename'].'.xls'))
    262                         {
    263                         foreach($tab_objet[$objet]['xls'] as $extraction)
    264                         if(!file_exists($emplacement.$extraction['fichier_csv'])){
    265                                 conversion_fichier_excel($emplacement.$infos_fichier['filename'].'.xls',$emplacement.$extraction['fichier_csv'],$extraction['onglet'],$extraction['colonnes'],$extraction['ligne_depart'],$extraction['ligne_arrive']);
    266                                 }
    267                                 $fichier_modele=$emplacement.$tab_objet[$objet]['xls'][objet_type($objet)]['fichier_csv'];
    268                         }
    269 
    270         }
    271 }
    272 $table=table_objet_sql($objet);
    273 $tab_description=description_table($table);
    274 if($option_truncate==1) {
    275         $message.=  'Purge de la table '.$table."<br />";
    276         spip_mysql_query('truncate table '.$table);
    277         sql_delete($table,array("1"=>"1"));
    278         if(isset($tab_objet[$objet]['relation'])){
    279                 sql_delete("spip_cog_communes_liens",'objet='.sql_quote($objet));
    280                 }
    281         }
    282 
    283 $req_relation=array();
    284 if(isset($tab_objet[$objet]['relation'])){
    285         $tab_commune=sql_allfetsel('concat(departement,code) as code,id_cog_commune','spip_cog_communes');
    286         foreach($tab_commune as $com)
    287                 $tab_temp[$com['code']]=$com['id_cog_commune'];
    288         $tab_commune=$tab_temp;
    289 }
    290        
    291 
    292 $cle_unique=isset($tab_objet[$objet]['cle_unique'])?$tab_objet[$objet]['cle_unique']: array('code');
    293 $tab_objet_existant=sql_allfetsel(id_table_objet($table).','.implode(',',$cle_unique),$table);
    294 $tab_temp=array();
    295 foreach($tab_objet_existant as $ob){
    296         $super_cle=array();
    297         foreach($cle_unique as $cle)
    298                 $super_cle[]=$ob[$cle];
    299         $tab_temp[implode("-+-",$super_cle)]=$ob[id_table_objet($table)];
    300 }
    301 $tab_objet_existant=$tab_temp;
    302 
    303         $pointeur_fichier = fopen($fichier_modele,"r");
    304 if($pointeur_fichier<>0){
    305         $ligne= fgets($pointeur_fichier, 4096);
    306         $nb_ligne=0;
    307         while (!feof($pointeur_fichier)){
    308                 $ligne= fgets($pointeur_fichier, 4096);
    309                 $tab=explode("\t",$ligne);
    310                 if(count($tab)>1)
    311                 {
    312                         $tab_value=array();
    313                         $i=0;
    314                         reset($tab_description['field']);
    315                        
    316                         while(list ($key, $val) = each ($tab_description['field']))
    317                                 {
    318                                         if($option_decalage>$i)
    319                                         {
    320                                                 $i++;
    321                                                 continue;
    322                                         }
    323 
    324                                         if(isset($tab_objet[$objet]['correspondance']))
    325                                         {
    326                                                 $tab_correspondance=$tab_objet[$objet]['correspondance'];
    327                                                 if(isset($tab_correspondance[$key]))
    328                                                 {
    329 
    330                                                         if(!is_array($tab_correspondance[$key]))
    331                                                         {
    332                                                                 $tab_value[$key] = $tab[$tab_correspondance[$key]];
    333                                                         }
    334                                                         else
    335                                                         {
    336                                                                 if(isset($tab_correspondance[$key]['col']))
    337                                                                 {
    338                                                                                 if(isset($correspondance[$key]['fichier']))
    339                                                                                         $tab_value[$key]=cog_ramener_valeur($tab,$tab_correspondance[$key],$objet,$contenu_fichier);
    340                                                                                 else
    341                                                                                         $tab_value[$key]=cog_renvoyer_valeur($tab,$tab_correspondance[$key]);
    342                                                                 }
    343                                                                 else
    344                                                                 {
    345                                                                         $tab_value[$key]="" ;
    346                                                                         reset($tab_correspondance[$key]);
    347                                                                         while(list ($indice1, $valeur1) = each ($tab_correspondance[$key]))
    348                                                                                 $tab_value[$key] .=sql_quote(cog_renvoyer_valeur($tab,$valeur1));
    349                                                                 }
    350                                                         }
    351                                                 }
    352                                         }
    353                                                 else
    354                                                 {
    355                                                         $tab_value[$key] = utf8_encode(trim($tab[$i-$option_decalage]));
    356                                                 }
    357                                                 $i++;
    358                                 }
    359 
    360                                 $filtre_relation=false;
    361                                 if(isset($tab_objet[$objet]['relation']))
    362                                 {
    363                                         foreach($tab_objet[$objet]['relation'] as $key => $relation)
    364                                         {
    365                                                 $tab_depcom=cog_ramener_valeur($tab,$relation,$objet,$contenu_fichier,false);
    366                                         for($ii=0;$ii<count($tab_depcom);$ii++)
    367                                         {
    368                                                 $tab_depcom[$ii]=array('departement'=>substr($tab_depcom[$ii],0,2),'code'=>substr($tab_depcom[$ii],2));
    369 
    370                                                 if(!cog_applique_filtre($tab_depcom[$ii],$tab_filtres))
    371                                                         $filtre_relation=true;
    372 
    373                                         }
    374                                         }
    375                                 }
    376                                
    377                                 if(!cog_applique_filtre($tab_value,$tab_filtres) || $filtre_relation)
    378                                         continue;
    379                                
    380 
    381                                 $super_cle=array();
    382                                 $super_cles='';
    383                                 foreach($cle_unique as $cle){
    384                                         $super_cle[]=$tab_value[$cle];
    385                                         $super_cles.=$tab_value[$cle];
    386                                         }
    387                                 if (!empty($super_cles))
    388                                         {
    389                                         $existe_deja=false;
    390                                         if(isset($tab_objet_existant[implode("-+-",$super_cle)])){
    391                                                 $existe_deja=true;
    392                                                 $id_objet=$tab_objet_existant[implode("-+-",$super_cle)];
    393                                                 $where=id_table_objet($table).'='.intval($id_objet);
    394                                         }
    395 
    396                                         if($option_replace && $existe_deja)     {
    397                                                         sql_updateq($table, $tab_value, $where);
    398                                                 }
    399                                         elseif(!$existe_deja){
    400                                                         $id_objet=sql_insertq($table, $tab_value);
    401                                                 }
    402 
    403                                         // Ajout des éventuels liaison
    404                                         if(isset($tab_objet[$objet]['relation'])){
    405                                                 /*foreach($tab_depcom as $key=>$depcom){
    406                                                         if($id_cog_commune=$tab_commune[$depcom['departement'].$depcom['code']])
    407                                                                 sql_insertq("spip_cog_communes_liens",array('id_cog_commune'=>$id_cog_commune,'id_objet'=>$id,'objet'=> objet_type($objet)));
    408                                                         else
    409                                                                 $erreurs[]="Erreur grave Commune introuvable : ".$depcom['departement'].$depcom['code'];
    410                                                 }*/
    411                                                 $req=array();
    412                                                 foreach($tab_depcom as $key=>$depcom){
    413                                                         if(isset($tab_commune[$depcom['departement'].$depcom['code']]))
    414                                                                 $req_relation []= '('.implode(',',array($tab_commune[$depcom['departement'].$depcom['code']],$id_objet,"'".objet_type($objet)."'")).')';
    415 
    416                                                                 }
    417                                                                 }
    418 
    419                                         if(($nb_ligne%100)==0){
    420                                                         if(!empty($req_relation)){
    421                                                         $req_relation= "REPLACE INTO spip_cog_communes_liens  (id_cog_commune,id_objet,objet) VALUES ".implode(',',$req_relation);
    422                                                         if(!sql_query($req_relation))
    423                                                                 $erreurs[]="Erreur dans la création des relation avec les communes.";
    424                                         }
    425 
    426                                                         $req_relation=array();
    427                                 }
    428 
    429                                 $nb_ligne++;
    430                         }
    431                 }
    432         }
    433                         if(!empty($req_relation)){
    434                         $req_relation= "REPLACE INTO spip_cog_communes_liens  (id_cog_commune,id_objet,objet) VALUES ".implode(',',$req_relation);
    435                         if(!sql_query($req_relation))
    436                                 $erreurs[]="Erreur dans la création des relation avec les communes.";
    437                         }
    438                        
    439                 }
    440         $message.=$nb_ligne.' enregistrements ajoutés.';
    441         fclose($pointeur_fichier);
    442         return array($message,$erreurs);
    443 
    444 }
    445 
     233    if (is_array($tab_objet[$objet]['fichier'])) {
     234        $fichier_modele = $tab_objet[$objet]['fichier'][0];
     235    } else {
     236        $fichier_modele = $tab_objet[$objet]['fichier'];
     237    }
     238
     239    $infos_fichier = pathinfo($fichier_modele);
     240    $extension = $infos_fichier['extension'];
     241    if ($extension == 'zip') {
     242        $extension = 'txt';
     243    }
     244
     245    if (!file_exists($fichier_modele = realpath(_DIR_PLUGIN_COG . '/data') . '/' . $infos_fichier['filename'] . '.' . $extension)) {
     246
     247        if (!file_exists($fichier_modele = $emplacement . $infos_fichier['filename'] . '.' . $extension)) {
     248            if (file_exists($emplacement . $infos_fichier['filename'] . '.xls')) {
     249                foreach ($tab_objet[$objet]['xls'] as $extraction) {
     250                    if (!file_exists($emplacement . $extraction['fichier_csv'])) {
     251                        conversion_fichier_excel($emplacement . $infos_fichier['filename'] . '.xls',
     252                            $emplacement . $extraction['fichier_csv'], $extraction['onglet'], $extraction['colonnes'],
     253                            $extraction['ligne_depart'], $extraction['ligne_arrive']);
     254                    }
     255                }
     256                $fichier_modele = $emplacement . $tab_objet[$objet]['xls'][objet_type($objet)]['fichier_csv'];
     257            }
     258
     259        }
     260    }
     261    $table = table_objet_sql($objet);
     262    $tab_description = description_table($table);
     263    if ($option_truncate == 1) {
     264        $message .= 'Purge de la table ' . $table . "<br />";
     265        spip_mysql_query('truncate table ' . $table);
     266        sql_delete($table, array("1" => "1"));
     267        if (isset($tab_objet[$objet]['relation'])) {
     268            sql_delete("spip_cog_communes_liens", 'objet=' . sql_quote($objet));
     269        }
     270    }
     271
     272    $req_relation = array();
     273    if (isset($tab_objet[$objet]['relation'])) {
     274        $tab_commune = sql_allfetsel('concat(departement,code) as code,id_cog_commune', 'spip_cog_communes');
     275        foreach ($tab_commune as $com) {
     276            $tab_temp[$com['code']] = $com['id_cog_commune'];
     277        }
     278        $tab_commune = $tab_temp;
     279    }
     280
     281
     282    $cle_unique = isset($tab_objet[$objet]['cle_unique']) ? $tab_objet[$objet]['cle_unique'] : array('code');
     283    $tab_objet_existant = sql_allfetsel(id_table_objet($table) . ',' . implode(',', $cle_unique), $table);
     284    $tab_temp = array();
     285    foreach ($tab_objet_existant as $ob) {
     286        $super_cle = array();
     287        foreach ($cle_unique as $cle) {
     288            $super_cle[] = $ob[$cle];
     289        }
     290        $tab_temp[implode("-+-", $super_cle)] = $ob[id_table_objet($table)];
     291    }
     292    $tab_objet_existant = $tab_temp;
     293
     294    $pointeur_fichier = fopen($fichier_modele, "r");
     295    if ($pointeur_fichier <> 0) {
     296        $ligne = fgets($pointeur_fichier, 4096);
     297        $nb_ligne = 0;
     298        while (!feof($pointeur_fichier)) {
     299            $ligne = fgets($pointeur_fichier, 4096);
     300            $tab = explode("\t", $ligne);
     301            if (count($tab) > 1) {
     302                $tab_value = array();
     303                $i = 0;
     304                reset($tab_description['field']);
     305
     306                while (list ($key, $val) = each($tab_description['field'])) {
     307                    if ($option_decalage > $i) {
     308                        $i++;
     309                        continue;
     310                    }
     311
     312                    if (isset($tab_objet[$objet]['correspondance'])) {
     313                        $tab_correspondance = $tab_objet[$objet]['correspondance'];
     314                        if (isset($tab_correspondance[$key])) {
     315
     316                            if (!is_array($tab_correspondance[$key])) {
     317                                $tab_value[$key] = $tab[$tab_correspondance[$key]];
     318                            } else {
     319                                if (isset($tab_correspondance[$key]['col'])) {
     320                                    if (isset($correspondance[$key]['fichier'])) {
     321                                        $tab_value[$key] = cog_ramener_valeur($tab, $tab_correspondance[$key], $objet,
     322                                            $contenu_fichier);
     323                                    } else {
     324                                        $tab_value[$key] = cog_renvoyer_valeur($tab, $tab_correspondance[$key]);
     325                                    }
     326                                } else {
     327                                    $tab_value[$key] = "";
     328                                    reset($tab_correspondance[$key]);
     329                                    while (list ($indice1, $valeur1) = each($tab_correspondance[$key])) {
     330                                        $tab_value[$key] .= sql_quote(cog_renvoyer_valeur($tab, $valeur1));
     331                                    }
     332                                }
     333                            }
     334                        }
     335                    } else {
     336                        $tab_value[$key] = utf8_encode(trim($tab[$i - $option_decalage]));
     337                    }
     338                    $i++;
     339                }
     340
     341                $filtre_relation = false;
     342                if (isset($tab_objet[$objet]['relation'])) {
     343                    foreach ($tab_objet[$objet]['relation'] as $key => $relation) {
     344                        $tab_depcom = cog_ramener_valeur($tab, $relation, $objet, $contenu_fichier, false);
     345                        for ($ii = 0; $ii < count($tab_depcom); $ii++) {
     346                            $tab_depcom[$ii] = array(
     347                                'departement' => substr($tab_depcom[$ii], 0, 2),
     348                                'code' => substr($tab_depcom[$ii], 2)
     349                            );
     350
     351                            if (!cog_applique_filtre($tab_depcom[$ii], $tab_filtres)) {
     352                                $filtre_relation = true;
     353                            }
     354
     355                        }
     356                    }
     357                }
     358
     359                if (!cog_applique_filtre($tab_value, $tab_filtres) || $filtre_relation) {
     360                    continue;
     361                }
     362
     363
     364                $super_cle = array();
     365                $super_cles = '';
     366                foreach ($cle_unique as $cle) {
     367                    $super_cle[] = $tab_value[$cle];
     368                    $super_cles .= $tab_value[$cle];
     369                }
     370                if (!empty($super_cles)) {
     371                    $existe_deja = false;
     372                    if (isset($tab_objet_existant[implode("-+-", $super_cle)])) {
     373                        $existe_deja = true;
     374                        $id_objet = $tab_objet_existant[implode("-+-", $super_cle)];
     375                        $where = id_table_objet($table) . '=' . intval($id_objet);
     376                    }
     377
     378                    if ($option_replace && $existe_deja) {
     379                        sql_updateq($table, $tab_value, $where);
     380                    } elseif (!$existe_deja) {
     381                        $id_objet = sql_insertq($table, $tab_value);
     382                    }
     383
     384                    // Ajout des éventuels liaison
     385                    if (isset($tab_objet[$objet]['relation'])) {
     386                        /*foreach($tab_depcom as $key=>$depcom){
     387                            if($id_cog_commune=$tab_commune[$depcom['departement'].$depcom['code']])
     388                                sql_insertq("spip_cog_communes_liens",array('id_cog_commune'=>$id_cog_commune,'id_objet'=>$id,'objet'=> objet_type($objet)));
     389                            else
     390                                $erreurs[]="Erreur grave Commune introuvable : ".$depcom['departement'].$depcom['code'];
     391                        }*/
     392                        $req = array();
     393                        foreach ($tab_depcom as $key => $depcom) {
     394                            if (isset($tab_commune[$depcom['departement'] . $depcom['code']])) {
     395                                $req_relation [] = '(' . implode(',', array(
     396                                        $tab_commune[$depcom['departement'] . $depcom['code']],
     397                                        $id_objet,
     398                                        "'" . objet_type($objet) . "'"
     399                                    )) . ')';
     400                            }
     401
     402                        }
     403                    }
     404
     405                    if (($nb_ligne % 100) == 0) {
     406                        if (!empty($req_relation)) {
     407                            $req_relation = "REPLACE INTO spip_cog_communes_liens  (id_cog_commune,id_objet,objet) VALUES " . implode(',',
     408                                    $req_relation);
     409                            if (!sql_query($req_relation)) {
     410                                $erreurs[] = "Erreur dans la création des relation avec les communes.";
     411                            }
     412                        }
     413
     414                        $req_relation = array();
     415                    }
     416
     417                    $nb_ligne++;
     418                }
     419            }
     420        }
     421        if (!empty($req_relation)) {
     422            $req_relation = "REPLACE INTO spip_cog_communes_liens  (id_cog_commune,id_objet,objet) VALUES " . implode(',',
     423                    $req_relation);
     424            if (!sql_query($req_relation)) {
     425                $erreurs[] = "Erreur dans la création des relation avec les communes.";
     426            }
     427        }
     428
     429    }
     430    $message .= $nb_ligne . ' enregistrements ajoutés.';
     431    fclose($pointeur_fichier);
     432    return array($message, $erreurs);
     433
     434}
    446435
    447436
    448437function importer_fichier_distant($source)
    449438{
    450 include_spip('inc/distant');
    451 $fichier=copie_locale($source);
    452 
    453 
    454 
    455         include_spip('inc/pclzip');
    456         $archive = new PclZip($fichier);
    457         $archive->extract(
    458                   PCLZIP_OPT_PATH, _tmp_dir,
    459                   PCLZIP_CB_PRE_EXTRACT, 'callback_deballe_fichier'
    460                   );
    461         //$contenu = verifier_compactes($archive);
    462 
    463         effacer_repertoire_temporaire(_tmp_dir);
    464         return true;
    465 }
     439    include_spip('inc/distant');
     440    $fichier = copie_locale($source);
     441
     442
     443    include_spip('inc/pclzip');
     444    $archive = new PclZip($fichier);
     445    $archive->extract(
     446        PCLZIP_OPT_PATH, _tmp_dir,
     447        PCLZIP_CB_PRE_EXTRACT, 'callback_deballe_fichier'
     448    );
     449    //$contenu = verifier_compactes($archive);
     450
     451    effacer_repertoire_temporaire(_tmp_dir);
     452    return true;
     453}
     454
    466455unset($filterSubset);
    467456
    468457
    469 
    470 
    471 function conversion_fichier_excel($fichier_xls_in,$fichier_xls_out,$sheetname,$cols,$ligne_depart,$ligne_arrive)
    472 {
    473 $inputFileType = 'Excel5';
     458function conversion_fichier_excel($fichier_xls_in, $fichier_xls_out, $sheetname, $cols, $ligne_depart, $ligne_arrive)
     459{
     460    $inputFileType = 'Excel5';
    474461//      $inputFileType = 'Excel2007';
    475462//      $inputFileType = 'Excel2003XML';
    476463//      $inputFileType = 'OOCalc';
    477464//      $inputFileType = 'Gnumeric';
    478 $inputFileName = $fichier_xls_in;
    479 $chunkSize = 2000;
    480 $filterSubset = new MyReadFilter($cols);
    481 $sheetData=array();
    482 $objReader = PHPExcel_IOFactory::createReader($inputFileType);
    483 $objReader->setReadDataOnly(true);
    484 $objReader->setLoadSheetsOnly($sheetname);
    485 $objReader->setReadFilter($filterSubset);
    486 for ($startRow = $ligne_depart; $startRow <= $ligne_arrive; $startRow += $chunkSize) {
    487 $filterSubset->setRows($startRow,$chunkSize);
    488 $objPHPExcel = $objReader->load($inputFileName);
    489 $sheetData = $objPHPExcel->getActiveSheet()->toArray(null,false,true,false);
    490 $objPHPExcel->disconnectWorksheets();
    491 unset($objPHPExcel);
    492 $chaine="";
    493 foreach($sheetData as &$data)
    494         if(!empty($data[0]))
    495                 $chaine.=implode("\t",$data).PHP_EOL;
    496 file_put_contents($fichier_xls_out,$chaine,FILE_APPEND);
    497 unset($sheetData);
    498 unset($chaine);
    499 }
    500 unset($filterSubset);
    501 unset($objReader);
    502 return true;
     465    $inputFileName = $fichier_xls_in;
     466    $chunkSize = 2000;
     467    $filterSubset = new MyReadFilter($cols);
     468    $sheetData = array();
     469    $objReader = PHPExcel_IOFactory::createReader($inputFileType);
     470    $objReader->setReadDataOnly(true);
     471    $objReader->setLoadSheetsOnly($sheetname);
     472    $objReader->setReadFilter($filterSubset);
     473    for ($startRow = $ligne_depart; $startRow <= $ligne_arrive; $startRow += $chunkSize) {
     474        $filterSubset->setRows($startRow, $chunkSize);
     475        $objPHPExcel = $objReader->load($inputFileName);
     476        $sheetData = $objPHPExcel->getActiveSheet()->toArray(null, false, true, false);
     477        $objPHPExcel->disconnectWorksheets();
     478        unset($objPHPExcel);
     479        $chaine = "";
     480        foreach ($sheetData as &$data) {
     481            if (!empty($data[0])) {
     482                $chaine .= implode("\t", $data) . PHP_EOL;
     483            }
     484        }
     485        file_put_contents($fichier_xls_out, $chaine, FILE_APPEND);
     486        unset($sheetData);
     487        unset($chaine);
     488    }
     489    unset($filterSubset);
     490    unset($objReader);
     491    return true;
    503492}
    504493
    505494
    506495include_spip('lib/PHPExcel/Classes/PHPExcel/IOFactory');
     496
    507497class MyReadFilter implements PHPExcel_Reader_IReadFilter
    508498{
    509         private $_startRow = 0;
    510         private $_endRow = 0;
    511         private $_columns = array();
    512 
    513         public function __construct( $columns) {
    514                 $this->_columns         = $columns;
    515         }
    516 
    517     public function setRows($startRow, $chunkSize) {
    518         $this->_startRow = $startRow;
    519         $this->_endRow   = $startRow + $chunkSize;
    520     }
    521 
    522         public function readCell($column, $row, $worksheetName = '') {
    523                 if ($row >= $this->_startRow && $row <= $this->_endRow) {
    524                         if (in_array($column,$this->_columns)) {
    525                                 return true;
    526                         }
    527                 }
    528                 return false;
    529         }
    530 }
    531 
     499    private $_startRow = 0;
     500    private $_endRow = 0;
     501    private $_columns = array();
     502
     503    public function __construct($columns)
     504    {
     505        $this->_columns = $columns;
     506    }
     507
     508    public function setRows($startRow, $chunkSize)
     509    {
     510        $this->_startRow = $startRow;
     511        $this->_endRow = $startRow + $chunkSize;
     512    }
     513
     514    public function readCell($column, $row, $worksheetName = '')
     515    {
     516        if ($row >= $this->_startRow && $row <= $this->_endRow) {
     517            if (in_array($column, $this->_columns)) {
     518                return true;
     519            }
     520        }
     521        return false;
     522    }
     523}
    532524
    533525
  • _plugins_/COG/trunk/formulaires/telecharger_cog.html

    r82318 r95545  
    88        <ul>
    99        <li class="editer_fichier obligatoire[ (#ENV**{erreurs}|table_valeur{nom}|oui)erreur]">
    10                 <label for="fichier"><:cog:fichiers_a_telecharger:></label>[
     10                <label for="champs_fichier"><:cog:fichiers_a_telecharger:></label>[
    1111                <span class='erreur_message'>(#ENV**{erreurs}|table_valeur{fichier})</span>
    1212                ]<p class='explication'><:cog:choississez_le_fichier_a_telecharger:></p>
    1313
    1414
    15                 <select name='objet[]' multiple="multiple" >
     15                <select name='objet[]' multiple="multiple" id="champs_fichier" >
    1616
    1717                <BOUCLE_fichier(POUR){tableau #ENV{tab_objet}}>
  • _plugins_/COG/trunk/formulaires/telecharger_cog.php

    r94773 r95545  
    22
    33
    4 function formulaires_telecharger_cog_charger(){
    5 include_spip('cog_config');
    6 $tab_objet=cog_config_tab_fichier();
     4function formulaires_telecharger_cog_charger()
     5{
     6    include_spip('cog_config');
     7    $tab_objet = cog_config_tab_fichier();
    78
    8 foreach($tab_objet as $key=>&$objet)
    9 {
    10         //var_dump($fichier);
    11         if(is_array($objet['fichier'])){
    12                 $objet['fichier']=implode(',',$objet['fichier']);
    13         }
    14         if(preg_match('`^http`i',$objet['fichier'])){
    15                 $objet=$objet;
    16                 }
    17         else {
    18                 unset($tab_objet[$key]);
    19                 }
    20         }
     9    foreach ($tab_objet as $key => &$objet) {
     10        //var_dump($fichier);
     11        if (is_array($objet['fichier'])) {
     12            $objet['fichier'] = implode(',', $objet['fichier']);
     13        }
     14        if (preg_match('`^http`i', $objet['fichier'])) {
     15            $objet = $objet;
     16        } else {
     17            unset($tab_objet[$key]);
     18        }
     19    }
    2120
    2221
    23 return array('tab_objet'=>$tab_objet);
     22    return array('tab_objet' => $tab_objet);
    2423}
    2524
    2625
     26function formulaires_telecharger_cog_verifier_dist()
     27{
     28    include_spip('cog_config');
     29    include_spip('inc/config');
     30    $erreurs = array();
     31    $tab_objet = cog_config_tab_fichier();
     32    $objet = _request('objet');
     33    if (count($objet) < 1) {
     34        $erreurs['message_erreur'] = _T('cog:erreur_choix');
     35        $erreurs['objet'] = _T('cog:erreur_choix');
    2736
    28 
    29 function formulaires_telecharger_cog_verifier_dist(){
    30         include_spip('cog_config');
    31         include_spip('inc/config');
    32         $erreurs = array();
    33         $tab_objet=cog_config_tab_fichier();
    34         $objet = _request('objet');
    35         if (count($objet) < 1) {
    36                 $erreurs['message_erreur'] = _T('cog:erreur_choix');
    37                 $erreurs['objet'] = _T('cog:erreur_choix');
    38 
    39         }else{
    40                 if (!isset($tab_objet[$objet[0] ])) {
    41                         $erreurs['objet'] =  _T('cog:fichier_incorrect');
    42                         $erreurs['message_erreur'] = $erreurs['message_erreur']._T('cog:fichier_incorrect');
    43                 }
    44         }
    45         return $erreurs;
     37    } else {
     38        if (!isset($tab_objet[$objet[0]])) {
     39            $erreurs['objet'] = _T('cog:fichier_incorrect');
     40            $erreurs['message_erreur'] = $erreurs['message_erreur'] . _T('cog:fichier_incorrect');
     41        }
     42    }
     43    return $erreurs;
    4644}
    4745
    4846
    4947// http://doc.spip.org/@inc_editer_mot_dist
    50 function formulaires_telecharger_cog_traiter_dist(){
    51 include_spip('cog_config');
    52 include_spip('inc/cog_import');
    53 $tab_objet=cog_config_tab_fichier();
    54 $objet = array();
    55 $tab_fichier_telecharger=array();
     48function formulaires_telecharger_cog_traiter_dist()
     49{
     50    include_spip('cog_config');
     51    include_spip('inc/cog_import');
     52    $tab_objet = cog_config_tab_fichier();
     53    $objet = array();
     54    $tab_fichier_telecharger = array();
    5655
    57 $objet_nom="";
    58 $objet =_request('objet');
    59 for($i = 0; $i < count($objet); $i++){
    60         $objet_nom =$objet_nom.$objet[$i].' ';
    61         $tab_fichier=cog_tab_fichier_telecharger($tab_objet[$objet[$i] ]['fichier']);
    62         foreach($tab_fichier as $fichier) {
    63                 $nom_fichier=cog_telecharger_fichier_distant($fichier);
    64                 if($nom_fichier)
    65                         $tab_fichier_telecharger[]=$nom_fichier;
    66         }
    67 }
    68 $retour['editable']=true;
    69 if(count($tab_fichier_telecharger)==count($objet)){
    70         if (count($objet)==1) {
    71                 $retour['message_ok'] = 'Le fchier '.$objet_nom.' a bien été télécharger, vous pouvez procéder à son importation.';
    72         }else{
    73                 $retour['message_ok'] = 'Les fichiers '.$objet_nom.' ont bien été télécharger, vous pouvez procéder à leur importation.';
    74                 }
    75 } else {
    76         $retour['message_erreur'] = 'Problème dans l\'importation du fichier';
    77 }
    78 return $retour;
     56    $objet_nom = "";
     57    $objet = _request('objet');
     58    for ($i = 0; $i < count($objet); $i++) {
     59        $objet_nom = $objet_nom . $objet[$i] . ' ';
     60        $tab_fichier = cog_tab_fichier_telecharger($tab_objet[$objet[$i]]['fichier']);
     61        foreach ($tab_fichier as $fichier) {
     62            $nom_fichier = cog_telecharger_fichier_distant($fichier);
     63            if ($nom_fichier) {
     64                $tab_fichier_telecharger[] = $nom_fichier;
     65            }
     66        }
     67    }
     68    $retour['editable'] = true;
     69    if (count($tab_fichier_telecharger) == count($objet)) {
     70        if (count($objet) == 1) {
     71            $retour['message_ok'] = 'Le fchier ' . $objet_nom . ' a bien été télécharger, vous pouvez procéder à son importation.';
     72        } else {
     73            $retour['message_ok'] = 'Les fichiers ' . $objet_nom . ' ont bien été télécharger, vous pouvez procéder à leur importation.';
     74        }
     75    } else {
     76        $retour['message_erreur'] = 'Problème dans l\'importation du fichier';
     77    }
     78    return $retour;
    7979
    8080}
    8181
    8282
    83 
    8483function cog_telecharger_fichier_distant($source)
    8584{
    86 include_spip('inc/distant');
    87 include_spip('inc/config');
    88 $fichier=copie_locale($source);
    89 $infos_fichier=pathinfo($source);
    90 $emplacement=sous_repertoire(_DIR_TMP,lire_config('cog/chemin_donnee'));
    91 chmod($emplacement,0777);
    92 $nom_fichier=$emplacement.$infos_fichier['filename'].'.'.$infos_fichier['extension'];
    93 $nom_fichier_txt=$emplacement.$infos_fichier['filename'].'.txt';
    94 rename(_DIR_RACINE.$fichier,$nom_fichier);
    95 $infos_fichier=pathinfo($nom_fichier);
     85    include_spip('inc/distant');
     86    include_spip('inc/config');
     87    $fichier = copie_locale($source,'force');
     88    $infos_fichier = pathinfo($source);
     89    $emplacement = sous_repertoire(_DIR_TMP, lire_config('cog/chemin_donnee'));
     90    @chmod($emplacement, 0777);
     91    $nom_fichier = $emplacement . $infos_fichier['filename'] . '.' . $infos_fichier['extension'];
     92
     93    rename(_DIR_RACINE . $fichier, $nom_fichier);
     94    $infos_fichier = pathinfo($nom_fichier);
    9695
    9796// Si c'est un zip on l'extrait
    98 if($infos_fichier['extension']=='zip')
    99 {
     97    if ($infos_fichier['extension'] == 'zip') {
    10098
    101         include_spip('inc/pclzip');
    102         include_spip('inc/joindre_document');
    103         $archive = new PclZip($nom_fichier);
    104         $archive->extract(_DIR_TMP);
    105         $contenu = joindre_decrire_contenu_zip($archive);
     99        include_spip('inc/pclzip');
     100        include_spip('inc/joindre_document');
     101        $archive = new PclZip($nom_fichier);
     102        $archive->extract(_DIR_TMP);
     103        $contenu = joindre_decrire_contenu_zip($archive);
    106104
    107         if(isset($contenu[0]))  {
    108                 foreach ($contenu[0] as $fichier) {
    109                         rename(_DIR_TMP.$fichier['filename'],$emplacement.$fichier['filename']);
    110                 }
    111         }
    112         unlink($nom_fichier);
    113 }
     105        if (isset($contenu[0])) {
     106            foreach ($contenu[0] as $fichier) {
     107                rename(_DIR_TMP . $fichier['filename'], $emplacement . $fichier['filename']);
     108            }
     109        }
     110        unlink($nom_fichier);
     111    }
    114112
    115 return $nom_fichier;
     113    return $nom_fichier;
    116114
    117115}
    118116
    119117
    120 
    121 
    122 
    123118?>
  • _plugins_/COG/trunk/paquet.xml

    r95538 r95545  
    22        prefix="cog"
    33        categorie="outil"
    4         version="2.3.2"
     4        version="2.3.3"
    55        etat="stable"
    66        compatibilite="[3.0.0;3.1.*]"
Note: See TracChangeset for help on using the changeset viewer.